AARRCCHHIITTEECCTTUURREE DDEESS
OORRDDIINNAATTEEUURRSS
Gérard Dray Centre de Recherche LGI2P
École des Mines d'Alès Site EERIE
Parc Scientifique Georges Besse F30035 NIMES Cedex 1
Tel : +33 (0)4 66 38 70 34 - Fax : +33 (0)4 66 38 70 74
Email : [email protected]
Architecture des ordinateurs Gérard Dray – Ecole des Mines d'Alès
TABLE DES MATIERES 1. INTRODUCTION GENERALE................................................................................................. 3
1.1. Organisation générale d'un système informatique....................................................................................... 4
1.2. Un très bref historique................................................................................................................................. 5
1.3. Bibliographie............................................................................................................................................... 5
2. CODAGE DE L'INFORMATION.............................................................................................. 6 2.1. Systèmes de numération.............................................................................................................................. 6
2.1.1. Représentation d'un entier dans un système de numération pondérée.................................................................... 7
2.1.2. Représentation d'un nombre réel dans un système de numération pondérée.......................................................... 9
2.1.3. Conversion de systèmes de numération ................................................................................................................. 9
2.2. Codage de l'information ............................................................................................................................ 14 2.2.1. Codage des nombres entiers naturels ................................................................................................................... 14
2.2.2. Codage des nombres entiers relatifs..................................................................................................................... 15
2.2.3. Codage des nombres réels.................................................................................................................................... 18
2.2.4. Codage des caractères alphanumériques .............................................................................................................. 22
3. ELEMENTS DE LOGIQUE ..................................................................................................... 24 3.1. Algèbre de Boole....................................................................................................................................... 24
3.2. Axiomes, théorèmes et propriétés ............................................................................................................. 24
3.3. Algèbre de Boole à deux éléments ............................................................................................................ 26
4. ELEMENTS D'ARITHMETIQUE DES ORDINATEURS ................................................... 28 4.1. Addition binaire......................................................................................................................................... 28
4.2. Soustraction binaire................................................................................................................................... 29
4.3. Addition / Soustraction en complément à deux......................................................................................... 29
5. STRUCTURE ET FONCTIONNEMENT DES ORDINATEURS ........................................ 31 5.1. Éléments fonctionnels de base................................................................................................................... 31
5.1.1. Portes logiques et circuits combinatoires ............................................................................................................. 31
5.1.2. Bascules, registres et circuits séquentiels............................................................................................................. 32
5.1.3. Mémoire............................................................................................................................................................... 34
5.1.4. Unité Arithmétique et Logique ............................................................................................................................ 34
5.1.5. Bus et Logique trois états..................................................................................................................................... 36
5.2. Architecture et fonctionnement d’un ordinateur élémentaire .................................................................... 37 5.2.1. Structure de l’ordinateur élémentaire................................................................................................................... 37
5.2.2. Langage de description du fonctionnement de l’ordinateur élémentaire.............................................................. 40
5.2.3. Jeu d’instructions de l’ordinateur élémentaire ..................................................................................................... 40
5.2.4. Exécution d’un programme sur l’ordinateur élémentaire..................................................................................... 42
5.2.5. Aspects temporels de l’exécution d’un programme ............................................................................................. 46
5.3. Concepts avancés ...................................................................................................................................... 49 5.3.1. Classification des architectures............................................................................................................................ 49
5.3.2. Performances des microprocesseurs .................................................................................................................... 51
5.3.3. Caractéristiques des mémoires............................................................................................................................. 51
5.3.4. Organisation et gestion des mémoires.................................................................................................................. 52
5.3.5. Entrées sorties...................................................................................................................................................... 53
6. SOLUTIONS DES EXERCICES.............................................................................................. 54
2
Architecture des ordinateurs Gérard Dray – Ecole des Mines d'Alès
1. INTRODUCTION GENERALE
Architecture nf Structure, organisation de quelque chose.
Ordinateur nm Machine automatique de traitement de l'information.
L'électronique et l'informatique ont transformé et révolutionné nos
modes de communication et de traitement de l'information. Cette
formation à distance en est une parfaite illustration. Qui aurait pensé,
il y a 25 ans, que les ordinateurs permettraient un accès personnalisé et individuel à
la culture, à l'information et à la formation ? Certainement pas Ken Olsen, président
fondateur de Digital, qui en 1977 ne trouvait "aucune raison pour laquelle quiconque
désirerait avoir un ordinateur à la maison."
Les puces ont envahi notre quotidien, microprocesseurs, RAM, ROM
et autres insectes sont partout. Mais quels sont leurs langages ?
Comment sont-elles organisées ? Comment fonctionnent-elles ? Voici les questions
auxquelles nous allons essayer de répondre à travers ce module. L'objectif premier de
ce cours est de vous permettre de comprendre, d’analyser et d’avoir un avis critique
sur les architectures des systèmes informatiques actuels.
L’architecture des ordinateurs que nous connaissons aujourd’hui
résultent de la convergence et de la synthèse de nombreuses
sciences et technologies développées depuis le XVIème siècle.
Aussi, faire le tour de ce domaine en dix heures nous a paru trop
ambitieux. Nous avons donc été obligés de faire des choix dans les thèmes abordés
pour que ce module reste accessible dans cet intervalle de temps.
Ce cours s'articule autour deux grands axes. Le premier axe, composé des
trois premiers chapitres, nous permettra de comprendre le langage des
ordinateurs. A travers ces chapitres nous aborderons les différents
systèmes de codage de l'information, la logique booléenne et l'arithmétique
binaire. Ces bases théoriques alimenteront le dernier chapitre de ce cours, qui nous
permettra de décrypter et comprendre le fonctionnement complexe des systèmes
informatiques modernes.
3
Architecture des ordinateurs Gérard Dray – Ecole des Mines d'Alès
1.1. Organisation générale d'un système informatique
En première approche, un système informatique peut être vu comme un dispositif de
transmission, de traitement et de sauvegarde de l'information. Chaque système
informatique étant lui-même un élément d'un système d'échange et de traitement de
l'information. Comme le montre le dessin suivant, tout système informatique dispose
d'un ensemble identique de fonctions de communication, traitement et sauvegarde de
l'information.
Décodeur Récepteur
Voiede
transmission
Codeur Sourced ’information
TraitementSauvegarde
Systèmeinformatique
1
Systèmeinformatique
3
Systèmeinformatique
2
Systèmeinformatique
n
Voies de transmission
Figure 1
UC
Périphériques
Modem
Ecran
Imprimante
SourisClavier
Interfaces
Figure 2
4
Architecture des ordinateurs Gérard Dray – Ecole des Mines d'Alès
D'un point de vue structurel, tout système informatique est organisé autour d'une
unité centrale (UC) autour de laquelle gravitent des périphériques dialoguant avec
l'UC via des interfaces (cf. Figure 2). Tous les ordinateurs actuels, des micro-
ordinateurs aux gros systèmes, possèdent cette organisation. Les différences résident
essentiellement dans les performances des composants.
1.2. Un très bref historique
L'arbre généalogique des ordinateurs possède cinq principales générations en
fonction des technologies de conception utilisées.
• Génération zéro : 1642-1945
Technologie : mécanique
• Première génération : 1945-1955
Technologie : tubes à vide
• Deuxième génération : 1955-1965
Technologie : transistors
• Troisième génération : 1965-1971
Technologie : microprocesseurs LSI (Large Scale Integration) et VLSI (Very
Large Scale Integration
• Quatrième génération : depuis 1971
Technologie : microprocesseurs ULSI (Ultra Large Scale Integration)
1.3. Bibliographie
• Logique binaire - Fonctions logiques et arithmétique binaire
M. AUMIAUX - Masson
• Analyse et synthèse des systèmes logiques
D. Mange
• Structure et fonctionnement des ordinateurs
Meinadier
• Organisation et conception des ordinateurs
J. Hennessy, D. Patterson – Dunod
5
Architecture des ordinateurs Gérard Dray – Ecole des Mines d'Alès
2. CODAGE DE L'INFORMATION
"Toute chose est nombre"
Pythagore
22546F7574652063686F736520657374206E6F6D627265220D5079746B61676F7265
Traduction en ASCII hexadécimal
10001001010100011011111110101011101000110010100100000110001101101000
01101111011100111100101001000000110010101110011111010000100000011011
10011011111101101011000100111001001100101100010000011010101000001111
001111010001101011011000010110011111011110111001001100101
Traduction en ASCII binaire
Jusqu'à présent nous avons considéré l'ordinateur comme un organe de traitement, de
stockage et de transmission d'informations, sans nous préoccuper de savoir comment
ces informations étaient représentées. Nous allons maintenant nous attacher à
comprendre comment coder ces informations en binaire, c'est à dire sous la forme de
séquences de 0 et de 1 appelés bits (abréviation de binary digit).
A travers ce chapitre nous allons répondre aux questions suivantes
• Comment représenter un nombre entier ?
• Comment représenter un nombre entier négatif ?
• Comment représenter un nombre réel ?
• Comment représenter un caractère alphanumérique ?
2.1. Systèmes de numération
Un système de numération est la donnée d'un ensemble fini de symboles (digits ou
chiffres), et de règles permettant de représenter les éléments d'un ensemble fini ou
non N (ensemble des nombres) à l'aide des symboles de B.
On appelle codage de N à l'aide des symboles de B, une injection de N dans B*, où
B* est l'ensemble des suites ordonnées de 1, 2, …, p symboles de B.
Un codage fait donc correspondre à tout élément n de N un élément unique de B*
appelé mot.
On appellera code l'ensemble des mots de B* et base la cardinalité de B.
6
Architecture des ordinateurs Gérard Dray – Ecole des Mines d'Alès
Un code est dit pondéré si le poids correspondant à la position d'un chiffre dans un
mot est une constante quel que soit ce mot.
2.1.1. Représentation d'un entier dans un système de numération pondérée
Lorsque nous écrivons un nombre entier en décimal nous le notons dans sa forme
simplifiée et admise par tous. En toute rigueur, le nombre cent vingt sept devrait être
écrit pour indiquer le système de numération pondérée en base 10. Cette
notation nous permet de déchiffrer le code et d'exprimer le nombre dans sa forme
étendue : . Par simplification et parce que le
système décimal est le standard de numération dans le monde occidental ce nombre
est écrit 127.
( )10127
( )012
10 107102101127 ×+×+×=
Dans une numération pondérée chaque symbole composant le nombre est associé à
un poids fixe.
00111n1nnn011nn pdpd...pdpddd...ddA ×+×+×+×== −−−
B de symboles : di
ii d des poids : p
Si le système de numération est fondé sur une base b : ii bp =
Et nous notons ( )0
01
11n
1nn
nb011nn bdbd...bdbddd...ddA ×+×+×+×== −−−
Le digit d'indice le plus élevé est dit de poids fort et celui d'indice le plus petit est dit
de poids faible.
En informatique matérielle, pour des raisons que nous évoquerons plus tard les
systèmes de numération les plus souvent utilisés sont le binaire (base deux), l'octal
(base huit) et l'hexadécimal (base seize).
• Système de numération binaire :
• Base : 2
• Symboles : appelés également bit (abréviation de binary digit) { 1 0,B = }• Un mot composé de 8 bits est appelé octet (byte en anglais).
7
Architecture des ordinateurs Gérard Dray – Ecole des Mines d'Alès
• Les multiples kilo, méga, giga et téra sont fréquemment utilisés en
informatique pour quantifier des informations de grande taille. Ces
multiples sont exprimés en puissance de 2 comme représenté sur la table 1.
1 kilo octet (noté 1 ko) représente donc en réalité 1024 mots de 8 bits.
00010000000001077610995116272Ttéra10000000001010737418242Ggiga
10000001010485762Mméga10001010242kkilo
uesscientifiq Multiplesuesinformatiq MultiplesSymbolePréfixe
1240
930
620
310
========
Table 1
• Système de numération octal :
• Base : 8
• Symboles : { }7 6, 5, 4, 3, 2, 1, 0,B =
• Système de numération hexadécimal :
• Base : 16
• Symboles : { }F E, D, C, B, A, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0,B =
( ) ( ) ( ) ( )168210 3A43210100011163X ====
( )
( )
( )
( )0101
16
0128
012345672
01210
163161016316A3AX
838482432X
212120202021202110100011X
103106101163X
×+×=×+×==
×+×+×==
×+×+×+×+×+×+×+×==
×+×+×==
La taille de la représentation d'un nombre (quantité de digits) décroît inversement à
la valeur de la base. En effet, pour représenter le nombre "cent soixante trois" il faut
8 symboles en binaire, 3 en octal et seulement 2 en hexadécimal. Comme nous le
verrons plus tard, le passage entre ces bases étant trivial, les informaticiens préfèrent
utiliser l'octal ou l'hexadécimal pour représenter des nombres binaires.
8
Architecture des ordinateurs Gérard Dray – Ecole des Mines d'Alès
2.1.2. Représentation d'un nombre réel dans un système de numération pondérée
Nous décomposons la représentation en deux, pour la partie entière (avant la virgule)
nous utilisons la notation décrite dans le paragraphe précédent. Pour la partie
fractionnaire (après la virgule) on utilise les puissances négatives de la base.
( ) ( ) ( )( ) m
m1m
1m2
21
1bm1m21 bdbd...bdbddd...dd,0A −−
−−−−
−−
−−−−−−− ×+×+×+×==
( ) ( ) ( ) ( )
( ) ( )( )
( ) ( )( )
( ) ( )( )
( ) ( )( ) ( )( )101
101
16
1021
8
104321
2
104321
10
168210
161116BB,0X
848554,0X
212120211011,0X
1051071081066875,0X
B,054,01011,06875,0X
−−
−−
−−−−
−−−−
×=×==
×+×==
×+×+×+×===
×+×+×+×==
====
2.1.3. Conversion de systèmes de numération
Codage : passage de la base décimale dans une base b quelconque
Pour la partie entière il faut réaliser des divisions successives par la base et conserver
les restes. Pour la partie fractionnaire il faut réaliser des multiplications successives
par la base et conserver la partie entière.
Convertir ( )106875,163X = exprimé dans le système décimal en binaire, octal et
hexadécimal.
• Conversion en binaire de la partie entière ( )10163
Nous réalisons des divisions successives de la valeur par la base de conversion 2,
jusqu'à obtenir un quotient de 0. Le nombre converti se lit en reprenant les restes en
sens inverse.
9
Architecture des ordinateurs Gérard Dray – Ecole des Mines d'Alès
163031
281
81011
240
10100
205
51
22
20
21
11
20
40000
220
20000
210
( ) ( )210 10100011163X ==
DiviseurDividende
QuotientReste
Figure 3
• Conversion en binaire de la partie fractionnaire ( )106875,0
Nous réalisons des multiplications successives par la base de conversion 2 en
conservant la partie entière du résultat.
0,68752
1,375
x0,375
20,75
x0,75
21,5
x0,5
21,0
x( ) ( )210 0,10116875,0X ==
Figure 4
• Conversion en octal de la partie entière ( )10163
163033
820
20204
802
022
80
( ) ( )810 243163X ==
Figure 5
• Conversion en octal de la partie fractionnaire ( )106875,0
0,68758
5,5
x0,5
84,0
x ( ) ( )810 54,06875,0X ==
Figure 6
10
Architecture des ordinateurs Gérard Dray – Ecole des Mines d'Alès
• Conversion en hexadécimal de la partie entière ( )10163
16316 033
1610
1010
160
( ) ( )1610 A3163X ==
Le symbole de 10 en hexadécimal est A
Figure 7
• Conversion en hexadécimal de la partie fractionnaire ( )106875,0
0,68751611
x( ) ( )1610 B,06875,0X ==
Le symbole de 11 en hexadécimal est B
Figure 8
Une partie fractionnaire finie dans une base peut être infinie dans une autre base.
L'algorithme de conversion est interrompu lorsque la précision souhaitée est atteinte.
Décodage : passage d'une base b quelconque en base décimale
Pour convertir un nombre exprimé dans une base b dans la base décimale il suffit
d'exprimer la forme étendue du nombre :
( )
( )( ) m
m1m
1m2
21
10
01
11n
1nn
n
bm1m21011nn
bdbd...bdbdbdbd...bdbd
dd...dd , dd...ddA−
−−−
−−−
−−
−−
−
−−−−
×+×+×+×+×+×+×+×=
=
Convertir ( )21101,1011X = en décimal
( )10
43210123
8125 , 11X1611
810
411
21111214081X
2120212121212021X
=
×+×+×+×+×+×+×+×=
×+×+×+×+×+×+×+×= −−−−
11
Architecture des ordinateurs Gérard Dray – Ecole des Mines d'Alès
Convertir ( )875,531X = en décimal
( )10
21012
953125 , 345X6415
8171183645X
8587818385X
=
×+×+×+×+×=
×+×+×+×+×= −−
Convertir ( )16A0,F1CX = en décimal
( )10
21012
21012
390630 , 1033X256110
161011516125612X
161016016151611612X16A16016F16116CX
=
×+×+×+×+×=
×+×+×+×+×=
×+×+×+×+×=−−
−−
Transcodage : passage d'une base b1 dans une base b2
Pour passer d'une base de numération b1 quelconque dans une base b2 quelconque,
nous pouvons utiliser la base décimale comme pivot et réaliser un décodage puis un
codage - le transcodage direct imposant de réaliser des calculs en base b1 ou b2.
Dans le cas particulier ou le transcodage peut se faire directement comme
le montre les exemples suivants.
p1b2b =
Transcodage d'un nombre binaire en octal
31b2b 82b21b
=⎭⎬⎫
==
Il faut décomposer le nombre en blocs de 3 bits et convertir ces blocs directement en
octal.
( ) ( ) ( ) ( )
( ) ( ) ( ) ( )
( ) ( ) ( ) ( )
( ) ( ) ( ) ( )2828
2828
2828
2828
11170113110601021015001110040000
========
Table 2
12
Architecture des ordinateurs Gérard Dray – Ecole des Mines d'Alès
Convertir ( )200111,10111X = en octal
( )
( )8
2
16 , 27X110 001 , 111 010X
=
=
Nous avons rajouté des zéros non significatifs en début de la partie entière et en fin
de la partie rationnelle pour former les blocs de trois bits
Transcodage d'un nombre binaire en hexadécimal
41b2b 162b21b
=⎭⎬⎫
==
Il faut décomposer le nombre en blocs de 4 bits et convertir ces blocs directement en
hexadécimal.
( ) ( ) ( ) ( )
( ) ( ) ( ) ( )
( ) ( ) ( ) ( )
( ) ( ) ( ) ( )
( ) ( ) ( ) ( )
( ) ( ) ( ) ( )
( ) ( ) ( ) ( )
( ) ( ) ( ) ( )216216
216216
216216
216216
216216
216216
216216
216216
1111F1011B1110E1010A1101D100191100C10008
0111700113011060010201015000110100400000
========
========
Table 3
Convertir ( )210101,101101X = en hexadécimal
( )
( )16
2
A8 , 2DX1000 1010 , 1101 0010X
=
=
Nous avons rajouté des zéros non significatifs en début de la partie entière et en fin
de la partie rationnelle pour former les blocs de quatre bits
13
Architecture des ordinateurs Gérard Dray – Ecole des Mines d'Alès
(ARCHIE01A)
a) Dans quel système de numération pondéré les égalités suivantes sont-elles
vérifiées ?
( ) ( ) ( )bbb 1022 =+
( ) ( ) ( )bbb 1198594 =+
b) Codez en binaire les nombres suivants :
( )16ACA =
( )865B =
c) Codez en hexadécimal les nombres suivants :
( )211100A =
( )10231B =
d) Codez en octal les nombres suivants :
( )211100A =
( )10231B =
2.2. Codage de l'information
2.2.1. Codage des nombres entiers naturels
Le standard de codage des entiers naturels dans un ordinateur est le code binaire
naturel. Ce code consiste à représenter un entier sur un nombre de bits fixé, la
capacité de représentation dépendant directement de cette taille de représentation.
Si p représente la taille en nombre de bits de la représentation, la gamme des
nombres pouvant être codés varie de et le nombre de codes est 12 à 0 p − p2 .
Pour illustration, voici une table représentant le nombre le plus grand représentable
en fonction de p.
14
Architecture des ordinateurs Gérard Dray – Ecole des Mines d'Alès
3709551615184467440764429496729532
6553516255815432
12p p −
Table 4
2.2.2. Codage des nombres entiers relatifs
Comment coder des nombres entiers relatifs avec des 0 et des 1 ?
Voici la question à laquelle nous allons répondre à travers cette section. Les trois
codes que nous allons présenter possèdent tous la même contrainte, ils sont définis
pour une taille de bits déterminée a priori.
Codage signe et valeur absolue
La solution qui vient immédiatement à l'esprit est d'utiliser le bit de poids fort pour
coder le signe du nombre et les bits restants pour coder la valeur absolue du nombre.
En utilisant la convention suivante 0 code le signe positif + et 1 code le signe négatif
-, nous obtenons sur 4 bits le code présenté dans la table 5.
Le principal inconvénient de ce code est la double représentation du zéro (pour
l'exemple de la table 5 : 0000 et 1000), qui peut entraîner des lourdeurs de
programmation. D'autre part ce code ne possède pas de propriété arithmétique
particulière permettant de simplifier les opérations d'addition et de soustraction.
L'étendue de la représentation dépend de la taille du code utilisée. Si on représente
un nombre entier relatif N sur p bits avec le code signe et valeur absolue, alors ce
nombre devra être compris entre : ( ) ( )12 N 12- 1-p1-p −+≤≤− (cf. table 6).
Par exemple les nombres +10 et -9 ne peuvent pas être représentés sur 4 bits.
15
Architecture des ordinateurs Gérard Dray – Ecole des Mines d'Alès
Codage en complément à un
Le code en complément à un possède des propriétés arithmétiques intéressantes que
nous n'aborderons pas à travers ce cours.
• Le code en complément à un d'un nombre positif s'obtient en codant le nombre en
binaire naturel et en rajoutant des zéros non significatifs pour obtenir la taille
fixée a priori.
• Le code en complément à un d'un nombre négatif s'obtient en inversant bit à bit
le code de la valeur absolue du nombre.
Par exemple, si l'on souhaite coder le nombre N=-5 sur 4 bits (cf. Table 5) :
On considère en premier lieu sa valeur absolue : 5NV ==
Puis le code binaire sur 4 bits de cette valeur absolue : ( ) 0101V 2 =
Le code en complément à un s'obtient alors en inversant bit à bit : ( )2V ( ) 1010N 1C =
Ce code possède une double représentation du zéro (cf. Table 5 : 0000 et 1111).
L'étendue de la représentation dépend de la taille du code utilisée. Si on représente
un nombre entier relatif N sur p bits avec le code en complément à un, alors ce
nombre devra être compris entre : ( ) ( )12 N 12- 1-p1-p −+≤≤− (cf. table 6).
Par exemple les nombres +10 et -9 ne peuvent pas être représentés sur 4 bits.
107111121611103251101434110054310116521010761100187010007770111666011055501014440100333001122200101110001
00000002 à Complément1 à Complémentsigneet absolueValeur Code
−−−−−−−−−−−−−−−−−−−−−−−−+++++++++++++++++++++
++
Table 5
16
Architecture des ordinateurs Gérard Dray – Ecole des Mines d'Alès
Codage en complément à deux
Le complément à deux est le plus souvent utilisé pour coder les nombres entiers
relatifs. En effet, ce code possède une seule représentation du zéro et comme nous le
traiterons plus tard, certaines propriétés arithmétiques.
Le code en complément à deux s'obtient en ajoutant 1 au code en complément à un.
Mais comme nous n'avons pas encore traité l'addition d'un nombre binaire, voici une
méthode pour obtenir un code en complément à deux.
• Le code en complément à deux d'un nombre positif s'obtient en codant le nombre
en binaire naturel et en rajoutant des zéros non significatifs pour obtenir la taille
fixée a priori.
• Le code en complément à deux d'un nombre négatif s'obtient en considérant le
code binaire de la valeur absolue. Puis en parcourant les bits dans le sens des
poids croissant nous conservons les bits à l'identique jusqu'au premier 1 rencontré
inclus, puis nous inversons tous les bits jusqu'au bit de poids fort.
Par exemple, si l'on souhaite coder le nombre N=-6 sur 4 bits (cf. table 5).:
On considère en premier lieu sa valeur absolue : 6NV ==
Puis le code binaire sur 4 bits de cette valeur absolue : ( ) 0110V 2 =
En utilisant la méthode proposée, le code en complément à deux est : ( ) 1010N 2C =
Ce code possède une représentation unique du zéro.
L'étendue de la représentation dépend de la taille du code utilisée. Si on représente
un nombre entier relatif N sur p bits avec le code en complément à deux, alors ce
nombre devra être compris entre : ( ) ( )12 N 2- 1-p1-p −+≤≤ (cf. Table 6).
Ce code possède donc un nombre négatif de plus que les nombres positifs. Nombre de bits
p Min Max Min Max Min Max2 -1 1 -1 1 -24 -7 7 -7 7 -88 -127 127 -127 127 -128 127
16 -32767 32767 -32767 32767 -32768 3276732 -2147483647 2147483647 -2147483647 2147483647 -2147483648 2147483647
Signe et valeur absolue Complément à 1 Complément à 2
17
Table 6
17
Architecture des ordinateurs Gérard Dray – Ecole des Mines d'Alès
(ARCHIE02A)
a) On considère les 4 nombres codés sur 8 bits suivants : A=11101101
B=01100111
C=11111100
D=01111100
Donner pour chaque nombre son équivalent décimal suivant que l’on utilise le code
binaire naturel, le code en complément à 1 ou le code en complément à 2.
b) Coder en complément à 2 les nombres entiers signés suivants :
( )10100A +=
( )10100B −=
2.2.3. Codage des nombres réels
La représentation la plus répandue pour les nombres réels est la représentation en
virgule flottante. Dans cette représentation la position de la virgule n'est pas fixée a
priori mais est variable ("flottante") en fonction de la valeur d'un exposant. Pour
illustrer ce concept, voici comment coder en virgule flottante le nombre
réel ( )101964,2404R =
Il faut réaliser des décalages successifs de la virgule vers la gauche pour obtenir un
chiffre unique et non nul avant la virgule. Cette opération consiste à réaliser des
multiplications successives en décimal par et, pour conserver l'égalité, à
compenser par des multiplications par .
( )10110−
( )10110+
( )( ) ( )( )
( )( ) ( )( )
( )( ) ( )( )
-1 +1 +1
10 10
+1 -1 +1 +2
10 10
+2 -1 +1 +3
10 10
R= 2404,1964×10 ×10 = 240,41964×10
R= 240,41964×10 ×10 ×10 = 24,041964×10
R= 24,041964×10 ×10 ×10 = 2,4041964×10
Au final, R peut être exprimé par : ( )( )103104041964,2R ×=
• On appelle mantisse la valeur ( )104041964,2m = . La mantisse est dite
normalisée si la partie entière possède qu'un chiffre unique non nul.
• On appelle exposant la puissance de dix utilisée pour placer la virgule
. ( )103exp =
18
Architecture des ordinateurs Gérard Dray – Ecole des Mines d'Alès
Le même concept peut être repris pour une représentation des nombres réels en
binaire. Pour illustrer cette notion, considérons le nombre réel décimal :
. Convertissons ce nombre en binaire : ( )101875,0R = ( )20011,0R = . Puis réalisons
des décalages successifs de la virgule (cette fois ci vers la droite) pour obtenir un
chiffre 1 avant la virgule. Cette opération consiste à réaliser des multiplications
successives en binaire par et, pour conserver l'égalité, à compenser par des
multiplications en binaire par .
( )2110+
( )2110−
( )( ) ( )( )
( )( ) ( )( )
( )( ) ( )( )211
21110
210
2111
21
211
101,11010101,1R
1011,0101010011,0R
10011,010100011,0R
−−−
−−−
−−
×=×××=
×=×××=
×=××=
Au final, R peut être exprimé par : ( )( )211101,1R −×=
mantisse : ( )21,1m = et exposant : ( )211exp −= .
Pour coder un nombre en virgule flottante dans un ordinateur la norme est le standard
IEEE 754 simple ou double précision. Ces codes comportent pour la simple précision
32 bits et pour la double précision 64 bits.
31 30 29 28 27 26 25 24 23 22 21 20 19 18 17 16 15 14 13 12 11 10 9 8 7 6 5 4 3 2 1 0
Signe 1 bitExposant 8 bitsMantisse 23 bits
Codage IEEE 754 simple précision 63 62 61 60 59 58 57 56 55 54 53 52 51 50 49 48 47 46 45 44 43 42 41 40 39 38 37 36 35 34 33 3231 30 29 28 27 26 25 24 23 22 21 20 19 18 17 16 15 14 13 12 11 10 9 8 7 6 5 4 3 2 1 0
Signe 1 bitExposant 11 bitsMantisse 52 bits
Codage IEEE 754 double précision
Les concepteurs de la norme IEEE754 souhaitaient définir une représentation qui
puisse aussi être facilement soumise à des opérations entières. C'est pourquoi le bit
de signe est le bit de poids fort, ce qui permet de réaliser rapidement des tests
d'infériorité, supériorité ou égalité à zéro. La convention de signe utilisée est la
suivante : le 0 représente le signe + et le 1 représente le signe -.
Pour également faciliter le tri de nombres réels, l'exposant est codé en excès. Ce type
de représentation consiste à ajouter à la valeur réelle de l'exposant une constante qui
permette de représenter l'exposant le plus négatif par tous les bits à 0.
19
Architecture des ordinateurs Gérard Dray – Ecole des Mines d'Alès
Par exemple pour le codage IEEE 754 simple précision, l'exposant est codé sur 8 bits
et l'excès a été fixé à ( ) ( )210 01111111127 = . Ce qui signifie que l'exposant le plus
petit représentable par ce code est -127, qui sera codé en machine
et l'exposant le plus grand est +127 qui sera
codé en machine : ( .
( )( ) ( )210 000000000excès127 ==+−
)( ) ( )210+127+excès=254 =11111110
Afin d'augmenter la taille de la mantisse, le bit 1 avant la virgule est implicite et
n'apparaît pas dans le codage machine de la mantisse.
La valeur réelle d'un nombre réelle codé sous la forme signe, exposant, mantisse est :
( ) ( )( )2excèsosantexpsigne 10mantisse11R −×+×−=
Pour illustrer le code IEEE 754 simple précision qui en premier abord peut dérouter,
essayons de décoder la représentation suivante : 31 30 29 28 27 26 25 24 23 22 21 20 19 18 17 16 15 14 13 12 11 10 9 8 7 6 5 4 3 2 1 01 1 0 0 0 0 0 0 1 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0
Le bit de signe est à 1 donc le signe est négatif.
La mantisse est ( )( )200000000000000100000000,01m +=
D'où ( )( )200000000000000100000000,1m =
L'exposant est : ( )( ) ( )( ) ( )( )222 000000100111111110000001excès10000001 =−=−
Au final le nombre R représenté est :
( ) ( )( )
( ) ( )( )
( )( )
( )10
2
2000000101
2excèsosantexpsigne
5R
000000000000000000000,101R
1000000000000000100000000,11R
10mantisse11R
−=
−=
××−=
×+×−= −
En sens inverse essayons de coder le nombre ( )100,0390625R += .
Convertissons ce nombre en binaire : ( )20000101,0R +=
Puis déplaçons la virgule pour normaliser la représentation : ( )( )21011001,1R −×+=
Le signe du nombre est positif donc le bit de signe sera 0
L'exposant réel est ( )2réel 101exp −= auquel il faut ajouter l'excès pour obtenir son
code machine.
( )( ) ( )( ) ( )( )222réelexcès 011110100111111100000101excèsexpexp =+−=+=
20
Architecture des ordinateurs Gérard Dray – Ecole des Mines d'Alès
La mantisse codée ne tient pas compte du 1 avant la virgule ce qui donne sur 23 bits :
( )( )200000000000000100000000m =
Au final le code machine obtenu sur 32 bits pour ( )100,0390625R += est :
31 30 29 28 27 26 25 24 23 22 21 20 19 18 17 16 15 14 13 12 11 10 9 8 7 6 5 4 3 2 1 00 0 1 1 1 1 0 1 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0
Le codage IEEE 754 en virgule flottante ne permet pas une représentation exacte du
zéro. En effet le zéro sera codé par le plus petit nombre représentable : 31 30 29 28 27 26 25 24 23 22 21 20 19 18 17 16 15 14 13 12 11 10 9 8 7 6 5 4 3 2 1 00 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0
Qui en réalité correspond à :
( ) ( )( )
( ) ( )( )
( )( )
( ) ( )1039
10127
21111111
201111111000000000
2excèsosantexpsigne
10843682686141114375395,877471752R
101R
1000000000000000000000000,11R
10mantisse11R
−−
−
−
−
×≈+=
×+=
××−=
×+×−=
Comme pour le zéro un certain nombre de codes sont réservés, la table suivante
récapitule ces conventions. Objet représenté
Exposant Mantisse Exposant Mantisse0 0 0 0 00 ≠0 0 ≠0 Nombre denormalisé
1 à 254 quelconque 1 à 2046 quelconque Nombre flottant255 0 2047 0 Infini255 ≠0 2047 ≠0 NaN (Not a Number)
Simple précision Double précision
Table 7
Le codage d'un nombre réel est pratiquement toujours une approximation de la valeur
réelle du nombre. Des erreurs de troncature et de calcul peuvent être induites par ces
approximations. Les programmeurs se doivent de tenir compte de ces imprécisions
lors de calculs scientifiques.
(ARCHIE03A)
Coder en utilisant le codage en virgule flottante IEEE simple précision les nombres
réels suivants :
( )1075,9A −= et ( )1015625,0B +=
21
Architecture des ordinateurs Gérard Dray – Ecole des Mines d'Alès
2.2.4. Codage des caractères alphanumériques
En ce qui concerne le codage des caractères alphanumériques, le code standard
ASCII semble incontournable. Cependant les limitations de ce code sur 8 bits, dans
un contexte de mondialisation des échanges de documents électroniques, posent un
problème. Aussi, un nouveau mode de représentation des caractères alphanumériques
tente de s'imposer : l'Unicode.
Le code ASCII
Le code ASCII (American Standard Code for Information Interchange), initialement
développé pour les échanges par télétexte, est un standard de représentation sur 7
bits. L'essor de l'informatique et de son unité de base ont rajouté un bit à cette
représentation. Seuls les 128 premiers codes (représentation sur 8 bits 0XXXXXXX)
sont standards. Les 128 autres codes (1XXXXXXX) sont utilisés pour coder des
caractères spécifiques à une langue comme par exemples les caractères accentués en
Français. Les 32 premiers codes sont des codes de contrôle tels que le caractère de
tabulation ou de nouvelle ligne.
Desc. Desc. Desc. Desc. Desc. Desc. Desc.déc. hex. déc. hex. déc. hex. déc. hex. déc. hex. déc. hex. déc. hex. déc. hex.000 00 NUL (null) 032 20 ESPACE 064 40 @ 096 60 ` 128 80 Ç 160 A0 á 192 C0 À 224 E0 à001 01 SOH (start of heading) 033 21 ! 065 41 A 097 61 a 129 81 ü 161 A1 ¡ 193 C1 Á 225 E1 á002 02 STX (start of text) 034 22 " 066 42 B 098 62 b 130 82 ‚ 162 A2 ¢ 194 C2  226 E2 â003 03 ETX (end of text) 035 23 # 067 43 C 099 63 c 131 83 ƒ 163 A3 £ 195 C3 à 227 E3 ã004 04 EOT (end of transmission) 036 24 $ 068 44 D 100 64 d 132 84 „ 164 A4 ¤ 196 C4 Ä 228 E4 ä005 05 ENQ (enquiry) 037 25 % 069 45 E 101 65 e 133 85 ... 165 A5 ¥ 197 C5 Å 229 E5 å006 06 ACK (acknowledge) 038 26 & 070 46 F 102 66 f 134 86 † 166 A6 ¦ 198 C6 Æ 230 E6 æ007 07 BEL (bell) 039 27 ' 071 47 G 103 67 g 135 87 ‡ 167 A7 § 199 C7 Ç 231 E7 ç008 08 BS (backspace) 040 28 ( 072 48 H 104 68 h 136 88 ˆ 168 A8 ¨ 200 C8 È 232 E8 è009 09 TAB (horizontal tab) 041 29 ) 073 49 I 105 69 i 137 89 ‰ 169 A9 (c) 201 C9 É 233 E9 é010 0A LF (line feed, new line) 042 2A * 074 4A J 106 6A j 138 8A Š 170 AA ª 202 CA Ê 234 EA ê011 0B VT (vertical tab) 043 2B + 075 4B K 107 6B k 139 8B ‹ 171 AB ½ 203 CB Ë 235 EB ë012 0C FF (form feed, new page) 044 2C , 076 4C L 108 6C l 140 8C Œ 172 AC ¬ 204 CC Ì 236 EC ì013 0D CR (carriage return) 045 2D - 077 4D M 109 6D m 141 8D ì 173 AD - 205 CD Í 237 ED í014 0E SO (shift out) 046 2E . 078 4E N 110 6E n 142 8E Ä 174 AE (r) 206 CE Î 238 EE î015 0F SI (shift in) 047 2F / 079 4F O 111 6F o 143 8F Å 175 AF ¯ 207 CF Ï 239 EF ï016 10 DLE (data link escape) 048 30 0 080 50 P 112 70 p 144 90 É 176 B0 ° 208 D0 Ð 240 F0 ð017 11 DC1 (device control 1) 049 31 1 081 51 Q 113 71 q 145 91 ' 177 B1 ± 209 D1 Ñ 241 F1 ñ018 12 DC2 (device control 2) 050 32 2 082 52 R 114 72 r 146 92 ' 178 B2 ² 210 D2 Ò 242 F2 ò019 13 DC3 (device control 3) 051 33 3 083 53 S 115 73 s 147 93 ô 179 B3 ³ 211 D3 Ó 243 F3 ó020 14 DC4 (device control 4) 052 34 4 084 54 T 116 74 t 148 94 ö 180 B4 ´ 212 D4 Ô 244 F4 ô021 15 NAK (negative acknowledge) 053 35 5 085 55 U 117 75 u 149 95 • 181 B5 µ 213 D5 Õ 245 F5 õ022 16 SYN (synchronous idle) 054 36 6 086 56 V 118 76 v 150 96 - 182 B6 ¶ 214 D6 Ö 246 F6 ö023 17 ETB (end of trans. block) 055 37 7 087 57 W 119 77 w 151 97 - 183 B7 · 215 D7 × 247 F7 ÷024 18 CAN (cancel) 056 38 8 088 58 X 120 78 x 152 98 ˜ 184 B8 ¸ 216 D8 Ø 248 F8 ø025 19 EM (end of medium) 057 39 9 089 59 Y 121 79 y 153 99 (tm) 185 B9 ¹ 217 D9 Ù 249 F9 ù026 1A SUB (substitute) 058 3A : 090 5A Z 122 7A z 154 9A š 186 BA º 218 DA Ú 250 FA ú027 1B ESC (escape) 059 3B ; 091 5B [ 123 7B { 155 9B › 187 BB + 219 DB Û 251 FB û028 1C FS (file separator) 060 3C < 092 5C \ 124 7C | 156 9C œ 188 BC + 220 DC Ü 252 FC ü029 1D GS (group separator) 061 3D = 093 5D ] 125 7D } 157 9D Ø 189 BD ¢ 221 DD Ý 253 FD ý030 1E RS (record separator) 062 3E > 094 5E ^ 126 7E ~ 158 9E ž 190 BE ¥ 222 DE Þ 254 FE þ031 1F US (unit separator) 063 3F ? 095 5F _ 127 7F ¦ 159 9F Ÿ 191 BF ¿ 223 DF ß 255 FF ÿ
CodesCodes Standards Codes Libres
Codes Codes Codes CodesDesc. Codes Codes Codes
Table 8
La table 8 représente la table de caractères ASCII en langue française. Les colonnes
codes représentent le code décimal et hexadécimal du caractère représenté dans la
colonne "Desc.".
Par exemple le code ( ) ( )1610 68104 = représente le caractère h.
22
Architecture des ordinateurs Gérard Dray – Ecole des Mines d'Alès
L'unicode
Avant l'invention d'Unicode, de nombreux systèmes de codage de caractères ont été
développés, mais pas un seul d'entre eux n'était satisfaisant de par la diversité des
caractères et langues à coder. Par exemple, l'Union Européenne a besoin de plusieurs
systèmes de codage pour couvrir toutes ses langues d'usage. Même pour une seule
langue comme le français, aucun système de codage ne couvrait toutes les lettres, les
signes de ponctuation et les symboles techniques en usage courant.
Ces systèmes de codage sont souvent incompatibles entre eux. Ainsi, deux systèmes
peuvent utiliser le même nombre pour deux caractères différents ou utiliser différents
nombres pour le même caractère. Les ordinateurs, et plus particulièrement les
serveurs, doivent supporter plusieurs systèmes de codage de caractères, ce qui crée
un risque de corruption des données à chaque transition.
Unicode spécifie un numéro unique pour chaque caractère, quelle que soit la plate-
forme, quel que soit le logiciel et quelle que soit la langue. Unicode est utilisé dans
de nombreux systèmes d'exploitation, dans tous les navigateurs récents, et dans de
nombreux autres produits. L'apparition du standard Unicode, ainsi que la
disponibilité d'outils le gérant, sont parmi les faits les plus marquants de la
globalisation récente du développement logiciel. Grâce à Unicode, un seul logiciel ou
site Internet peut satisfaire simultanément et sans modification les demandes de
plusieurs plate-formes, langues et pays. Unicode permet aussi à des logiciels de
provenance variée d'échanger des caractères sans pertes de données.
Le lecteur intéressé par ce code, pourra trouver toutes les informations utiles sur le
site internet : http://www.unicode.org
23
Architecture des ordinateurs Gérard Dray – Ecole des Mines d'Alès
3. ELEMENTS DE LOGIQUE
3.1. Algèbre de Boole
Une algèbre de Boole est définie par le sextuplé <E, + , . , , 0 , 1> où E est un
ensemble quelconque, et . sont des opérateurs binaires appelés respectivement
addition booléenne (également appelé OU) et produit booléen (également appelé
ET), et
+
est une loi unaire dite de complémentarité booléenne (également appelé
NON). 0 et 1 sont respectivement la borne inférieure et la borne supérieure.
3.2. Axiomes, théorèmes et propriétés
Les éléments de E satisfont les propriétés suivantes : soit ( ) 3Ec,b,a ∈ .
• Axiome 1
Il existe un élément unique E0∈ et un élément unique E1∈ tels que :
1a) 1b) a0a =+ a1a =⋅
• Axiome 2
Il existe un élément unique E0∈ et un élément unique E1∈ tels que :
2a) 2b) 11a =+ 00a =⋅
• Axiome 3 : Idempotence
3a) 3b) aaa =+ aa.a =
• Axiome 4 : Complémentarité
4a) 1aa =+ 4b) 0a . a =
• Axiome 5 : Involution
5) aa =
• Axiome 6 : Commutativité
6a) 6b) abba +=+ a . bb . a =
• Axiome 7 : Associativité
7a) ( ) ( ) cbacba ++=++ 7b) ( ) ( ) c . b . ac . b . a =
• Axiome 8 : Distributivité
8a) ( ) c . ab . acb . a +=+ 8b) ( ) ( )ca . bac . ba ++=+
24
Architecture des ordinateurs Gérard Dray – Ecole des Mines d'Alès
• Éléments neutres
0 est l’élément neutre pour + aa00a =+=+
1 est l’élément neutre pour . aa . 11 . a ==
Absorption ab . aa =+
( ) aba . a =+
Simplification bab . aa +=+
( ) b . aba . a =+
Théorème de De Morgan
• n...21n21 x . . x . xx...xx =+++
• n...21n...21 x xx.x ..xx +++=
Théorème de consensus
• z . xy .x z .y z . xy .x +=++
• ( ) ( ) ( ) ( ) ( )zx . yxzy . zx . yx ++=+++
(ARCHIE04A)
Démontrez les égalités suivantes en utilisant exclusivement les axiomes de base de
l'Algèbre de Boole :
a) bab.aa +=+
b) ( ) aba.a =+
c) x.bx.ab.ax.bx.a +=++
25
Architecture des ordinateurs Gérard Dray – Ecole des Mines d'Alès
3.3. Algèbre de Boole à deux éléments
Une Algèbre de Boole à deux éléments est une algèbre de Boole où E = {0 , 1}
On appelle constante booléenne les valeurs 0 ou 1
On appelle variable booléenne une variable appartenant à {0, 1}
Expression Booléenne : combinaison de variables, de constantes et d’opérateurs
( )n21 x,...,x,xexpression
( ) 3213211 xx.xx,x,xexpression +=
Fonction Booléenne : valeurs prises par une expression booléenne pour toutes les
combinaisons de , généralement exprimée sous la forme d'une table de
vérité.
n21 x,...,x,x
Table de vérité des opérateurs : { }. , , +
11011010010111000100
b.acbacacba =+==
26
Architecture des ordinateurs Gérard Dray – Ecole des Mines d'Alès
Table de vérité de l'expression booléenne : ( ) 3213211 xx.xx,x,xexpression +=
11111011010110010110101001001000
xx.xxxx 321321 +
(ARCHIE05A)
Écrire la table de vérité des expressions suivantes :
a) ( ) c.ad.cd,c,b,af1 +=
b) ( ) d.c.b.ac.b.ad.c.b.ad.c.ad,c,b,af2 +++=
Que remarque-t-on ?
27
Architecture des ordinateurs Gérard Dray – Ecole des Mines d'Alès
4. ELEMENTS D'ARITHMETIQUE DES ORDINATEURS
Dans ce chapitre nous allons traiter les opérations d'addition et de soustraction
binaires. Pour les opérations de multiplication et de division binaires et les opérations
en virgule flottante, le lecteur intéressé trouvera matière dans les références
bibliographiques citées en début de cours.
4.1. Addition binaire
L'opération d'addition binaire se réalise de la même façon qu'en décimal, en
propageant les retenues des digits de poids faibles vers les digits de poids forts et en
respectant la table d'addition suivante :
0111100110100000
SommeRetenueba
=+=+=+=+=+
Table 9
232960361
11
Sommeopérande Secondeopérande Première
Retenues
000101111010001011000101
1110000
++
Binaire Décimal
Dans cet exemple nous traitons le cas de l'addition de deux nombres binaires codés
sur un octet. Le résultat obtenu tient sur un octet, et est donc correct.
903980022
01
Sommeopérande Secondeopérande Première
Retenues
1010110011001101000111011
00011011
++
Retenue générée
Binaire Décimal
Cet exemple d'addition de deux nombres d'un octet donne un résultat supérieur à 255
et n'est donc pas correct sur huit bits. Ce dépassement de capacité est indiqué par la
génération d'une retenue.
28
Architecture des ordinateurs Gérard Dray – Ecole des Mines d'Alès
4.2. Soustraction binaire
L'opération de soustraction binaire se réalise également comme en décimal, en
propageant les emprunts des digits de poids faibles vers les digits de poids forts et en
respectant la table de soustraction suivante :
0011100111100000
DifférenceEmpruntba
=−=−=−=−=−
Table 10
18001
050-131
DifférenceEmprunt
opérande Secondeopérande Première
100010100000111
0100110011000001
−
Binaire Décimal
Dans cet exemple le résultat de la soustraction est correct, il n'y a pas de retenue
générée.
Retenue générée Retenue générée
2299...0011
31200-53100
DifférenceEmprunt
opérande Secondeopérande Première
010011011...000011111
10101011001110000100
−
Binaire Décimal
Dans le cas présenté ici, l'opération génère une retenue et donc un dépassement de
capacité sur huit bits. Le résultat obtenu n'est pas correct en binaire naturel mais l'est
en complément à deux; en effet, ( ) ( )102C 78110110010 −= .
4.3. Addition / Soustraction en complément à deux
Comme nous venons de le voir, réaliser des opérations d'addition et de soustraction
en binaire demande d'appliquer deux méthodes différentes. Pour unifier ces
méthodes, nous préférerons utiliser le codage des nombres négatif en complément à
deux. Au lieu de réaliser une soustraction, nous additionnerons un nombre négatif :
( )yxyx −+=−
29
Architecture des ordinateurs Gérard Dray – Ecole des Mines d'Alès
Les règles à appliquer pour interpréter les résultats d'addition en complément à deux
sont les suivantes :
1. Toujours ignorer les retenues générées
2. Si les opérandes sont de signes différents alors le résultat sera toujours juste
3. Si les opérandes sont de même signe, alors le résultat sera juste s’il est
également du même signe
( )( )
( )
( )
1100101111010
32
5
325
c2
c2
c2
++
−++−
En ignorant la retenue générée le résultat codé sur 4 bits est correct.
( )( )
( )
( )
( )
1001101111101
725
725
c2
c2
c2
+−
−+−+
−−−
En ignorant la retenue générée le résultat codé sur 4 bits est correct.
( )( )
( )
( )
( )
1110100111101
945
945
c2
c2
c2
+−
−+−+
−−−
En ignorant la retenue générée le résultat codé sur 4 bits est faux, en effet la somme
de deux nombres négatifs ne peut donner un nombre positif.
( )
( )
( )
111001001010
725
c2
c2
c2
++++
Le signe du résultat est équivalent au signe des opérandes, le résultat est donc
correct.
( )
( )
( )
100100101010
945
c2
c2
c2
++++
Le signe du résultat est différent du signe des opérandes, le résultat est donc faux.
(ARCHIE06A)
Reprenez l'exercice ARCHIE02A et calculez les sommes suivantes en binaire naturel
et en complément à deux :
DBSCASBAS
3
2
1
+=+=+=
Ces sommes sont-elles valides pour un codage sur 8 bits ?
30
Architecture des ordinateurs Gérard Dray – Ecole des Mines d'Alès
5. STRUCTURE ET FONCTIONNEMENT DES ORDINATEURS
5.1. Éléments fonctionnels de base
5.1.1. Portes logiques et circuits combinatoires
Les opérateurs de l'algèbre de Boole possèdent des équivalents électroniques que l'on
appelle portes logiques réalisées à l’aide de transistors. Les symboles associés à ces
portes sont donnés sur les figures suivantes.
Non :
ET :
OU :
Figure 9
Nous pouvons, en associant ces portes, réaliser des circuits plus complexes.
Réalisons un circuit logique accomplissant la fonction suivante :
b.ab.af1 +=
Figure 10
Cette fonction est également appelée ou exclusif (symbole ⊕ ), sa table de vérité et
son symbole électronique sont les suivants :
011101110000
baba ⊕
Table 11
31
Architecture des ordinateurs Gérard Dray – Ecole des Mines d'Alès
Réalisons un circuit logique d'addition de deux bits :
Additiona
b
Somme
Retenue Figure 11
La table de vérité de ce circuit est la suivante :
0111100110100000
SommeRetenueba
Table 12
Dans la colonne de la Retenue nous reconnaissons la table de vérité d'un ET et dans
la colonne Somme la table de vérité d’un OU EXCLUSIF. Un additionneur de deux
bits peut donc être réalisé à l'aide de portes logiques, comme le montre la figure 12.
Toute fonction booléenne peut être réalisée à l’aide d’un assemblage de portes
logiques. Nous parlerons alors de systèmes combinatoires, c’est à dire de systèmes
dont les valeurs de sortie ne dépendent que des valeurs d’entrée présentes.
Figure 12
5.1.2. Bascules, registres et circuits séquentiels
Jusqu’à présent, nous n’avons abordé que des systèmes logiques combinatoires,
certains systèmes logiques nécessitent de mémoriser une valeur. C’est le cas, par
exemple, d’un compteur, l’état de comptage doit être conservé pour qu’à l’instant
suivant celui-ci soit incrémenté. La sortie d’un tel dispositif ne dépend donc pas
uniquement des entrées présentes, mais également des entrées passées. Un tel
système doit donc posséder une fonction de mémorisation.
Parce que le temps nous manquerait, nous n’aborderons pas à travers ce cours la
synthèse des systèmes logiques séquentiels, nous ne traiterons que les notions de
bascule et de registre.
32
Architecture des ordinateurs Gérard Dray – Ecole des Mines d'Alès
L’élément logique de base permettant de mémoriser un bit de mémoire est appelé
bascule. Cet élément est un bistable, c’est à dire qu’il possède deux états stables
représentant le 0 et le 1 binaire. La bascule la plus simple est la bascule D, dont le
symbole est représenté sur la figure 13. D est l'entrée de donnée, C l'entrée de
commande et Q la sortie indiquant l'état de la bascule. Le petit triangle sur l'entrée C
indique que les changements d'état sont effectués sur des fronts montants.
D
C
Q
Figure 13
La table de vérité et le chronogramme de la bascule D sont les suivants :
111101010000
QQD +
C
D
Q
Table 13
Un registre informatique est un dispositif logique permettant de mémoriser un mot
binaire. Suivant la taille du mot on parlera alors de registre 4bits, 8bits, 16 bits etc…
Pour réaliser physiquement on utilise plusieurs bascules mis en parallèle. L’exemple
suivant (figure 14) montre comment réaliser un registre 4 bits à l’aide de bascules D.
Sur un front montant du signal W, le mot de 4 bits D3 D2 D1 D0 est écrit dans le
registre. Tant que le signal W ne génère pas de front montant, le mot est mémorisé
est présenté sur les sorties Q3 Q2 Q1 Q0.
Q0
Q1
Q2
Q3
D0
D1
D2
D3
W
D
C
Q
D
C
Q
D
C
Q
D
C
Q
.
.
.
Figure 14
33
Architecture des ordinateurs Gérard Dray – Ecole des Mines d'Alès
5.1.3. Mémoire
Une mémoire informatique est un dispositif physique permettant d’écrire, de
mémoriser et de lire de l’information binaire. Tout phénomène physique bistable
permet de réaliser un élément mémoire d’un bit (également appelé point ou cellule
mémoire). Par exemple un interrupteur possède 2 états stables qui permettent de
réaliser un point mémoire : lorsque l’interrupteur est fermé, on code un 1 et à
l’inverse lorsqu’il est ouvert, on code un 0. Comme nous l’avons vu précédemment
une bascule forme également un point mémoire.
Adressen
012
i
2n-1
Donnée
D0D1Dm-1 Dj
EcritureLecture
Figure 16
Dans cette section nous traiterons la mémoire comme en élément fonctionnel de base
sans considérer la technologie utilisée. En première approximation une mémoire peut
être considérée comme un tableau de bits. L’entrée d’adresse permet de sélectionner
un mot de bit dans le tableau. Suivant le mode choisi, écriture ou lecture, la donnée
de m bits est écrite dans la mémoire ou lue à partir de la mémoire.
5.1.4. Unité Arithmétique et Logique
Une Unité Arithmétique et Logique (UAL) est un élément fonctionnel qui permet,
comme son nom l’indique, de réaliser des opérations logiques et arithmétiques. Les
UAL les plus récentes, intégrées dans les microprocesseurs, permettent de réaliser
des opérations en nombre entier et en virgule flottante.
Une version d’une UAL simple est représentée sur la figure 15. Cette UAL possède :
• deux entrées de données E1 et E2 de 8 bits
• une sortie de données S de 8 bits
34
Architecture des ordinateurs Gérard Dray – Ecole des Mines d'Alès
• une entrée COP qui permet de coder sur 3 bits l’opération à réaliser sur E1
et E2.
• une sortie ETAT qui permet de coder sur 2 bits l’état l’opération qui vient
d’être effectuée.
UALCOP
ETAT
E1 E2
S
8 8
3
2 8
Figure 15
Les huit opérations possibles sur cette UAL sont :
• NOT : non logique S=NOT(E2), code binaire 000
• INC : incrémentation S=(E2 + 1), code binaire 001
• DEC : décrémentation S=(E2 - 1), code binaire 010
• AND : et logique S=(E1 AND E2), code binaire 011
• OR : ou logique S=(E1 OR E2), code binaire 100
• XOR : ou exclusif logique S=(E1 XOR E2), code binaire 101
• ADD : addition binaire S=(E1 + E2), code binaire 110
• SUB : soustraction binaire S=(E1 – E2), code binaire 111
La sortie ETAT possède 2 bits nommés C et Z.
Le bit C permet de savoir si l’opération arithmétique réalisée a généré une retenue
• C=0 si aucune retenue n’est générée
• C=1 si une retenue est générée
Le bit Z permet de savoir si la sortie S est à zéro après une opération arithmétique ou
logique.
• Z=0 si S est différent de zéro
• Z=1 si S est égal à zéro
Voici quelques exemples de fonctionnement de cette UAL : E1 E2 COP S
C Z01010101 11010100 011 01010100 0 001110101 00010011 110 10001000 0 010110111 11011111 110 10010110 1 010101010 10101010 111 00000000 0 111001100 11111111 001 00000000 1 1
ETAT
Table 14
35
Architecture des ordinateurs Gérard Dray – Ecole des Mines d'Alès
5.1.5. Bus et Logique trois états
Dans les sections précédentes, nous avons traité les principaux composants
fonctionnels de tout ordinateur indépendamment les uns des autres. Pour compléter
cette étude nous devons maintenant comprendre comment ces éléments dialoguent et
échangent des informations.
Le dispositif le plus simple pour créer des voies de communication entre les éléments
fonctionnels est le bus. Un bus est un ensemble de connexions (fils) sur lesquels vont
circuler des informations binaires. Les bus sont partagés entre plusieurs composants
Un seul composant à la fois peut y faire circuler une information, alors que plusieurs
composants peuvent avoir accès à cette information.
Comment permettre à un composant de prendre la main sur le bus et aux autres de le
laisser libre ? C’est le rôle du contrôleur de bus et des buffers trois état.
Commande
Entrée Sortie
Figure 17
Un buffer peut être considéré comme un interrupteur commandé. Le symbole d’un
buffer est représenté sur la figure 17. Si l’entrée de commande est valide alors le
signal d’entrée est disponible en sortie. Si l’entrée de commande est invalidée alors
la sortie est déconnectée de l’entrée, on parle alors d’état haute impédance Z, c’est
comme si une résistance infinie était disposée entre l’entrée et la sortie.
La figure 18 représente un exemple de fonctionnement d’un bus trois états. On
souhaite réaliser un transfert du contenu du registre R1 vers le registre R3. Pour cela
il faut donner l’autorisation à R1 de prendre la main sur le bus en validant le signal
C1 tout en invalidant le signal C2 pour déconnecter R2 du bus. Une fois que le
contenu de R1 est présent et stable sur le bus on peut donner l’ordre d’écriture dans
R3 en validant W3. Le transfert est réalisé et il ne reste plus qu’à libérer le bus en
invalidant C1.
36
Architecture des ordinateurs Gérard Dray – Ecole des Mines d'Alès
.0
1
1
1
.
.
.
.1
0
1
0
.
.
.
0
1
1
1
..
..
..
.. .
..
.
C1
C2
W1
W2
W3
R1
R2
R3
BUS4 bits
Z
Z
Z
Z
0
1
1
1
0111
Figure 18
5.2. Architecture et fonctionnement d’un ordinateur élémentaire
5.2.1. Structure de l’ordinateur élémentaire
Dans cette section nous allons présenter l’architecture d’un ordinateur basé sur le
modèle de Von Neumann datant des années 50. Aussi curieux que cela puisse
paraître, ce modèle est toujours d’actualité, et tous les ordinateurs modernes sont
encore basés sur cette architecture.
L’architecture que nous proposons est décrite sur la figure 19. C’est une architecture
4 bits, c’est à dire que tout les registres (sauf le registre d’état qui est de 2 bits), le
bus de données et le bus d’adresses véhiculent des mots de 4 bits.
Voici une description structurelle de cette architecture :
• Unité de contrôle : c’est le système nerveux de l’architecture. C’est cette unité
qui génère tous les signaux permettant à un programme de s’exécuter
correctement. Une entrée d’horloge (CLK) permet de synchroniser toutes les
opérations qui s’exécutent sur cette architecture. Un signal de réinitialisation
(RST) permet de remettre à l’état initial toute l’architecture. Cette unité possède
également un registre d’état (RE) de 2 bits qui mémorise les bits de retenue et de
zéro générés par l’UAL.
37
Architecture des ordinateurs Gérard Dray – Ecole des Mines d'Alès
• Mémoire Principale : c’est une mémoire de 16 mots de 4 bits. Elle contient le
programme à exécuter et également les données à traiter. Elle possède deux
entrées de commande :
• L permet d’effectuer une lecture de la mémoire, c’est à dire que la valeur
contenue à l’adresse pointée par RA est positionnée sur le bus de données.
• E permet une écriture dans la mémoire. La valeur présente sur le bus de
données est écrite dans la case mémoire pointée par RA.
• CO : Compteur Ordinal (ou compteur programme). Ce registre contient l’adresse
de l’instruction à exécuter. Il possède 3 entrées de commande : CO+1 qui permet
d’incrémenter le registre d’une unité sans utiliser l’UAL, SCO permet d’écrire
une valeur présente sur le bus de données dans CO, RST qui permet de
réinitialiser le registre à la valeur 0.
• BCO : Buffer du registre CO. Permet de connecter ou déconnecter CO du bus de
données. Si son entrée de commande SBCO est valide alors CO est présent sur le
bus de données, sinon CO est complètement isolé du bus.
• RA : Registre d’adresse. Il permet de sélectionner la case mémoire à lire ou à
écrire.
• BRA : Buffer du registre d’adresse, il permet de connecter ou de déconnecter RA
du bus d’adresse pour accéder à la mémoire principale.
• RI1 et RI2 : Registres instruction, contiennent le code de l’instruction à exécuter.
La sortie de RI1 est connecté à l’unité de contrôle pour permettre le décodage de
l’instruction.
• UAL : cette unité arithmétique et logique possède les mêmes fonctionnalités que
celle présenté à la section 5.1.3. en 4 bits.
• R1, R2 et R3 : registres de l’UAL. Les opérations sont effectuées entre R1 et R2
et le résultat est mémorisé dans R3.
• BR3 : Buffer du registre R3
• ACCU : Registre accumulateur, c’est le seul registre utilisateur, c’est à dire que
c’est le seul registre accessible directement par le programmeur. Tous les autres
registres sont dits : registre système.
• BACCU : Buffer du registre ACCU.
38
Architecture des ordinateurs Gérard Dray – Ecole des Mines d'Alès
Bus
de d
onné
es
Bus
de c
ontr
ôle
SACC
U
Bus
d’ad
ress
es
SBA
CCU
SR3 SB
R3
SCO
SBCO
SRI1
SRA
SBRA
E L
COP
ETA
T
CLK
RST
RST
Sign
aux
de c
ontr
ôle
SR1
SR2
RI1
RA
Mém
oire
Prin
cipa
le
UA
L
BACC
UBC
OBR
ABR
3
Uni
téde
cont
rôle
R2R1
COR3
ACC
U
CO+1
RE (C
,Z)
SRI2
SBRI
2
BRI2
RI2
Figure 19
39
Architecture des ordinateurs Gérard Dray – Ecole des Mines d'Alès
5.2.2. Langage de description du fonctionnement de l’ordinateur élémentaire
Pour décrire le fonctionnement de notre ordinateur élémentaire, nous adoptons une
notation appelée : « transfert de registres » (RTL : Register Transfer Language) dont
voici la syntaxe :
• Le signe % précédant un nombre indique que celui-ci est exprimé en binaire.
• Le signe $ précédant un nombre indique que celui-ci est exprimé en hexadécimal.
• Une ou plusieurs lettres indiquent un élément mémoire (registre ou case
mémoire). Par exemple RA indique le registre d’adresse et M(%0010) indique la
mémoire à l’adresse %0010 notée en binaire.
• La notation entre crochets [ ] indique le contenu de cet élément mémoire. Par
exemple [RA] indique le contenu du registre RA et [M(%0010)] indique le
contenu de la mémoire à l’adresse %0010.
• Une flèche dirigée vers la gauche indique la copie d’un élément mémoire ou
d’une expression vers un autre élément mémoire.
Par exemple [M(%0100)] <= [RA] indique que le contenu de RA est copié dans
la mémoire à l’adresse %0100. Il est à noter que le contenu de RA n’est pas
altéré.
Un autre exemple : l’expression [CO] <= [CO] + 1 indique que le contenu du
compteur ordinal est incrémenté d’une unité.
5.2.3. Jeu d’instructions de l’ordinateur élémentaire
Pour pouvoir programmer cet ordinateur, nous devons le munir d’un jeu
d’instructions. Voici les instructions de notre architecture virtuelle classées en trois
catégories : les instructions arithmétiques et logiques, les instructions de mouvement
et les instructions de branchement.
Instructions arithmétiques et logiques
Ces instructions utilisent l’UAL, les bits du registre d’état sont donc modifiés. Le
paramètre ADR de l’instruction est une adresse mémoire, l’opérande est le contenu
de cette adresse
• NOT ADR, le contenu de la case mémoire M(ADR) est complémenté bit à bit :
[M(ADR)] <= NOT [M(ADR)]
• INC ADR, le contenu de la case mémoire M(ADR) est incrémenté :
[M(ADR)] <= [M(ADR)] + 1
40
Architecture des ordinateurs Gérard Dray – Ecole des Mines d'Alès
• DEC ADR, le contenu de la case mémoire M(ADR) est décrémenté :
[M(ADR)] <= [M(ADR)] - 1
• AND ADR, le contenu de la case mémoire M(ADR) reçoit le ET logique entre sa
valeur et le contenu de ACCU :
[M(ADR)] <= [ACCU] AND [M(ADR)]
• OR ADR, le contenu de la case mémoire M(ADR) reçoit le OU logique entre sa
valeur et le contenu de ACCU :
[M(ADR)] <= [ACCU] OR [M(ADR)]
• XOR ADR, le contenu de la case mémoire M(ADR) reçoit le OU EXCLUSIF
logique entre sa valeur et le contenu de ACCU :
[M(ADR)] <= [ACCU] XOR [M(ADR)]
• ADD ADR, le contenu de la case mémoire M(ADR) reçoit l’addition
arithmétique entre sa valeur et le contenu de ACCU :
[M(ADR)] <= [ACCU] + [M(ADR)]
• SUB ADR, le contenu de la case mémoire M(ADR) reçoit la soustraction
arithmétique entre le contenue de ACCU et sa valeur :
[M(ADR)] <= [ACCU] - [M(ADR)]
Instructions de mouvement
Ces instructions permettent de réaliser des transferts de données entre le registre
ACCU et la mémoire. Elles n’utilisent pas l’UAL et ne modifient donc pas le registre
d’état.
• LDA ADR, le contenu de la case mémoire M(ADR) est transféré dans le registre
ACCU : [ACCU] <= [M(ADR)]
• STA ADR, le contenu du registre ACCU est transféré dans la mémoire à
l’adresse ADR: [M(ADR)] <= [ACCU]
• LDAI VAL, le registre ACCU reçoit la valeur VAL : [ACCU] <= VAL
Instructions de branchement
Le paramètre est une adresse et le programme réalise un branchement à cette adresse.
Branchement inconditionnel :
• BR ADR : le registre CO reçoit l’adresse passée en paramètre
[CO] <= ADR
41
Architecture des ordinateurs Gérard Dray – Ecole des Mines d'Alès
Branchement conditionnel : le branchement est réalisé suivant la valeur des bits du
registre d’état
• BC0 ADR : si C=0 alors [CO] <= ADR
• BC1 ADR : si C=1 alors [CO] <= ADR
• BZ0 ADR : si Z=0 alors [CO] <= ADR
• BZ1 ADR : si Z=1 alors [CO] <= ADR
La table suivante récapitule le jeu d’instruction en précisant le code binaire associé à
chaque instruction. Code
%0000 NOT ADR [M(ADR)] <= NOT [M(ADR)]%0001 INC ADR [M(ADR)] <= [M(ADR)] + 1%0010 DEC ADR [M(ADR)] <= [M(ADR)] - 1%0011 AND ADR [M(ADR)] <= [ACCU] AND [M(ADR)]%0100 OR ADR [M(ADR)] <= [ACCU] OR [M(ADR)]%0101 XOR ADR [M(ADR)] <= [ACCU] XOR [M(ADR)]%0110 ADD ADR [M(ADR)] <= [ACCU] + [M(ADR)]%0111 SUB ADR [M(ADR)] <= [ACCU] - [M(ADR)]%1000 LDA ADR [ACCU] <= [M(ADR)]%1001 STA ADR [M(ADR)] <= [ACCU]%1010 LDAI VAL [ACCU] <= VAL%1011 BR ADR [CO] <= ADR%1100 BCO ADR [CO] <= ADR Si C=0%1101 BC1 ADR [CO] <= ADR Si C=1%1110 BZ0 ADR [CO] <= ADR Si Z=0%1111 BZ1 ADR [CO] <= ADR Si Z=1
Mnémonique Opération
Table 15
5.2.4. Exécution d’un programme sur l’ordinateur élémentaire
Nous allons maintenant nous intéresser à l’exécution d’un programme sur cette
architecture. Le programme est contenu dans la mémoire principale, par convention
celui-ci débute à l’adresse %0000. Pour pouvoir être exécutée chaque instruction doit
être envoyée dans les registres instruction RI1 et RI2. C’est le rôle de la phase de
recherche de l’instruction en mémoire ou « cycle fetch ». Ensuite, suivent les phases
d’exécution de l’instruction et de préparation de l’instruction suivante.
Phase de recherche de l’instruction en mémoire
Cette phase est la même pour toutes les instructions, voici une description des
différentes étapes de cette phase
1. Le contenu du compteur ordinal est envoyé dans le registre d’adresse RA. Pour
réaliser ce transfert le signal du buffer de CO (SBCO) est validé. La valeur
contenue dans CO est positionnée sur le bus de données. Le signal d’écriture
42
Architecture des ordinateurs Gérard Dray – Ecole des Mines d'Alès
dans RA (SRA) est alors validé et le transfert est terminé. Tous les signaux
utilisés sont alors invalidés.
Nous adopterons la notation suivante pour décrire cette opération de base appelée
également micro-opération. Les signaux utilisés sont notés entre accolades.
[RA] <= [CO] {SBCO, SRA}
2. Le contenu de la mémoire à l’adresse contenue dans RA est transféré dans le
registre instruction RI1. Pour cela le buffer de RA est validé (SBRA) ce qui a
pour effet de positionner le contenu du registre RA sur le bus de données. Le
contenu de la case mémoire pointée est alors positionné sur le bus de données en
validant le signal de lecture de la mémoire (L). Enfin le signal SRI est validé
pour permettre l’écriture dans RI1.
[RI1] <= [M([RA])] {SBRA, L, SRI1}
3. Les instructions sont toutes codées sur deux adresses consécutives. Le compteur
ordinal est alors incrémenté pour pointer sur la seconde partie de l’instruction.
[CO] <= [CO] + 1 {CO+1}
4. Le contenu du compteur ordinal est envoyé dans le registre d’adresse RA .
[RA] <= [CO] {SBCO, SRA}
5. Le contenu de la mémoire à l’adresse contenue dans RA est transféré dans le
registre instruction RI2.
[RI2] <= [M([RA])] {SBRA, L, SRI2}
Phase d’exécution de l’instruction
Le registre RI1 contient le code de l’instruction à exécuter. Ce registre est
directement connecté à l’unité de contrôle, qui peut alors décoder l’instruction et
générer les signaux nécessaires.
Cette phase dépend donc de l’instruction à réaliser.
Phase de préparation de l’instruction suivante
L’exécution de l’instruction terminée, il faut placer dans le compteur ordinal
l’adresse de l’instruction suivante. Cette phase dépend également de l’instruction qui
vient d’être exécutée. S’il s’agit d’une instruction de branchement alors CO pourra
prendra l’adresse passée en paramètre. Par contre s’il s’agit d’un autre type
d’instruction ou si le test de l’instruction de branchement conditionnelle est faux il
faut passer à l’instruction suivante et incrémenter CO.
43
Architecture des ordinateurs Gérard Dray – Ecole des Mines d'Alès
Voici le contenu de la mémoire et des registres au début de l’exécution du
programme, les valeurs X signifient que le contenu de la case mémoire ou du registre
est inconnu. Adresse Mémoire Contenu Regitre Contenu
%0000 %1010 ACCU %XXXX%0001 %1011 R1 %XXXX%0010 %0101 R2 %XXXX%0011 %1100 R3 %XXXX%0100 %1000 CO %0000%0101 %1100 RI1 %XXXX%0110 %1011 RI2 %XXXX%0111 %0110 RE %XX%1000 %XXXX RA %XXXX%1001 %XXXX%1010 %XXXX%1011 %XXXX%1100 %1110%1101 %1010%1110 %1100%1111 %0010
Table 16
Nous allons décrire à l’aide de micro-opérations l’exécution du programme.
Phase de recherche de l’instruction en mémoire
[RA] <= [CO] {SBCO, SRA} [CO]=%0000
[RI1] <= [M([RA])] {SBRA, L, SRI1} [RI1]=%1010
[CO] <= [CO] + 1 {CO+1} [CO]=%0001
[RA] <= [CO] {SBCO, SRA} [RA]=%0001
[RI2] <= [M([RA])] {SBRA, L, SRI2} [RI2]=%1011
Phase d’exécution de l’instruction
L’unité de contrôle décode le registre instruction [RI1] = %1010 qui est le code de
l’instruction LDAI.
[ACCU] <= [RI2] {SBRI2, SACCU} [ACCU] = %1011
Phase de préparation de l’instruction suivante
[CO] <= [CO] + 1 {CO+1} [CO] = %0010
Passage à l'instruction suivante
Phase de recherche de l’instruction en mémoire
[RA] <= [CO] {SBCO, SRA} [RA] = %0010
[RI1] <= [M([RA])] {SBRA, L, SRI1} [RI1] = %0101
[CO] <= [CO] + 1 {CO+1} [CO] = %0011
[RA] <= [CO] {SBCO, SRA} [RA] = %0011
[RI2] <= [M([RA])] {SBRA, L, SRI2} [RI2] = %1100
44
Architecture des ordinateurs Gérard Dray – Ecole des Mines d'Alès
Phase d’exécution de l’instruction
L’unité de contrôle décode le registre instruction [RI1] = %0101 qui est le code de
l’instruction XOR.
[R1] <= [ACCU] {SR1} [R1] = %1011
[RA] <= [RI2] {SBRI2, SRA} [RA] = %1100
[R2] <= [M([RA])] {SBRA, L, SR2} [R2] = %1110
[R3] <= [R1] XOR [R2] {COP=101, SR3} [R3] = %0101
[RE] <= C,Z [RE] = %00
M([RA]) <= [R3] {SBR3, SBRA, E} [M(%1100)]=%0101
Phase de préparation de l’instruction suivante
[CO] <= [CO] + 1 {CO+1} [CO] = %0100
Passage à l'instruction suivante
Phase de recherche de l’instruction en mémoire
[RA] <= [CO] {SBCO, SRA} [RA] = %0100
[RI1] <= [M([RA])] {SBRA, L, SRI1} [RI1] = %1000
[CO] <= [CO] + 1 {CO+1} [CO] = %0101
[RA] <= [CO] {SBCO, SRA} [RA] = %0101
[RI2] <= [M([RA])] {SBRA, L, SRI2} [RI2] = %1100
Phase d’exécution de l’instruction
L’unité de contrôle décode le registre instruction [RI1] = %1000 qui est le code de
l’instruction LDA.
[RA] <= [RI2] {SBRI2, SRA} [RA] = %1100
[ACCU] <= [M([RA])] {SBRA, L, SACCU} [ACCU] = %0101
Phase de préparation de l’instruction suivante
[CO] <= [CO] + 1 {CO+1} [CO] = %0110
Passage à l'instruction suivante
Phase de recherche de l’instruction en mémoire
[RA] <= [CO] {SBCO, SRA} [RA] = %0110
[RI1] <= [M([RA])] {SBRA, L, SRI1} [RI1] = %1011
[CO] <= [CO] + 1 {CO+1} [CO] = %0111
[RA] <= [CO] {SBCO, SRA} [RA] = %0111
[RI2] <= [M([RA])] {SBRA, L, SRI2} [RI2] = %0110
45
Architecture des ordinateurs Gérard Dray – Ecole des Mines d'Alès
Phase d’exécution de l’instruction
L’unité de contrôle décode le registre instruction [RI1] = %1011 qui est le code de
l’instruction de branchement BR.
[CO] <= [RI2] {SBRI2, SCO} [CO] = %0110
Phase de préparation de l’instruction suivante
L’instruction étant un branchement, cette phase est vide
Le programme boucle indéfiniment à l’adresse %0110.
Le programme contenu en mémoire était donc : Adresse
%0000 LDAI %1011%0010 XOR %1100%0100 LDA %1100%0110 BR %0110
Instruction
5.2.5. Aspects temporels de l’exécution d’un programme
Jusqu’à présent nous nous sommes contentés de comprendre fonctionnellement
comment évolue notre architecture. Nous allons maintenant traiter l’aspect temporel
de l’exécution d’un programme. Une micro-opération est exécutée en un cycle
d’horloge. Deux ou plusieurs micro-opérations peuvent être exécutées en parallèle si
elles n’utilisent pas les mêmes ressources. Pour comprendre cette notion nous allons
reprendre l’exemple précédent et préciser à quel cycle d’horloge sont exécutées les
micro-opérations.
Début du programme le compteur de cycle est initialisé à zéro
Phase de recherche de l’instruction en mémoire
Cycle 1 : [RA] <= [CO] {SBCO, SRA}
Cycle 2 : [RI1] <= [M([RA])] {SBRA, L, SRI1}
Cycle 2 : [CO] <= [CO] + 1 {CO+1}
Cycle 3 : [RA] <= [CO] {SBCO, SRA}
Cycle 4 : [RI2] <= [M([RA])] {SBRA, L, SRI2}
Durant le deuxième cycle nous avons pu exécuter deux micro-opérations car celles-ci
n’utilisent pas les mêmes ressources.
Phase d’exécution de l’instruction
Cycle 5 : [ACCU] <= [RI2] {SBRI2, SACCU}
46
Architecture des ordinateurs Gérard Dray – Ecole des Mines d'Alès
Phase de préparation de l’instruction suivante
Cycle 5 : [CO] <= [CO] + 1 {CO+1}
La même remarque que précédemment peut être faite sur le cinquième cycle
d’horloge. Il faut donc 5 cycles d’horloge pour exécuter l’instruction LDAI 1011
Le compteur de cycle est remis à zéro
Phase de recherche de l’instruction en mémoire
Cycle 1 : [RA] <= [CO] {SBCO, SRA}
Cycle 2 : [RI1] <= [M([RA])] {SBRA, L, SRI1}
Cycle 2 : [CO] <= [CO] + 1 {CO+1}
Cycle 3 : [RA] <= [CO] {SBCO, SRA}
Cycle 4 : [RI2] <= [M([RA])] {SBRA, L, SRI2}
Phase d’exécution de l’instruction
Cycle 5 : [R1] <= [ACCU] {SR1}
Cycle 5 : [RA] <= [RI2] {SBRI2, SRA}
Cycle 6 : [R2] <= [M([RA])] {SBRA, L, SR2}
Cycle 7 : [R3] <= [R1] XOR [R2] {COP=011, SR3}
Cycle 7 : [RE] <= C,Z
Cycle 8 : M([RA]) <= [R3] {SBR3, SBRA, E}
Phase de préparation de l’instruction suivante
Cycle 8 : [CO] <= [CO] + 1 {CO+1}
Il faut donc 8 cycles d’horloge pour exécuter l’instruction : XOR 1100
Le compteur de cycle est remis à zéro
Phase de recherche de l’instruction en mémoire
Cycle 1 : [RA] <= [CO] {SBCO, SRA}
Cycle 2 : [RI1] <= [M([RA])] {SBRA, L, SRI1}
Cycle 2 : [CO] <= [CO] + 1 {CO+1}
Cycle 3 : [RA] <= [CO] {SBCO, SRA}
Cycle 4 : [RI2] <= [M([RA])] {SBRA, L, SRI2}
Phase d’exécution de l’instruction
Cycle 5 :[RA] <= [RI2] {SBRI2, SRA}
Cycle 6 : [ACCU] <= [M([RA])] {SBRA, L, SACCU}
Phase de préparation de l’instruction suivante
Cycle 6 :[CO] <= [CO] + 1 {CO+1}
L’instruction LDA 1100 nécessite donc 6 cycles d’horloge.
47
Architecture des ordinateurs Gérard Dray – Ecole des Mines d'Alès
Le compteur de cycle est remis à zéro
Phase de recherche de l’instruction en mémoire
Cycle 1 : [RA] <= [CO] {SBCO, SRA}
Cycle 2 : [RI1] <= [M([RA])] {SBRA, L, SRI1}
Cycle 2 : [CO] <= [CO] + 1 {CO+1}
Cycle 3 : [RA] <= [CO] {SBCO, SRA}
Cycle 4 : [RI2] <= [M([RA])] {SBRA, L, SRI2}
Phase d’exécution de l’instruction
Cycle 5 :[CO] <= [RI2] {SBRI2, SCO}
L’instruction BR 0110 demande donc 5 tops d’horloge pour être exécutée.
La mise en parallèle des micro-opérations permet d’accélérer l’exécution des
programmes. Nous verrons par la suite une généralisation de ce principe appelé
« Pipeline ».
(ARCHIE07A)
On considère le contenu de la mémoire suivant : Adresse Contenu Regitre Contenu%0000 %1000 ACCU %XXXX%0001 %1101 R1 %XXXX%0010 %0110 R2 %XXXX%0011 %1111 R3 %XXXX%0100 %0010 CO %0000%0101 %1110 RI1 %XXXX%0110 %1110 RI2 %XXXX%0111 %0010 RE %XX%1000 %1011 RA %XXXX%1001 %1000%1010 %XXXX%1011 %XXXX%1100 %XXXX%1101 %0100%1110 %0011%1111 %0000
1. Décoder le programme implanté en mémoire à partir de l’adresse %0000
2. Donner les cycles, micro-opérations et les signaux nécessaires à l’exécution de ce
programme
48
Architecture des ordinateurs Gérard Dray – Ecole des Mines d'Alès
5.3. Concepts avancés
5.3.1. Classification des architectures
Classification en fonction du jeu d’instructions
On peut classifier les ordinateurs en fonction de la complexité de leur jeu
d’instructions. On différencie alors deux types d’architectures : les CISC (Complex
Instruction Set Computer) et les RISC (Reduced Instruction Set Computer).
Les ordinateurs à architecture CISC (Pentium, MC68000) possèdent un grand
nombre d’instructions (environ 500) de tailles différentes et de nombre de cycles
différent. Cette diversité et cette disparité des instructions ralentissent la phase de
recherche et de décodage des instructions et ne permettent pas d’en optimiser
l’exécution. Les ordinateurs à architecture RISC (i960, RS6000, DecAlpha)
possèdent moins de 200 instructions. La taille et la durée d’exécution des instructions
sont identiques ce qui permet un plus grand parallélisme lors de l’exécution.
La tendance actuelle semble montrer que les processeurs de type RISC sont plus
performants que les CISC bien que ces derniers ne soient plus des CISC à
proprement parler, mais plutôt des hybrides regroupant différentes technologies
comme le pipelining et le mode super-scalaire ou carrément CISC et RISC à la fois
comme le pentium pro (c'est un processeur RISC qui traduit les instructions CISC).
Classification en fonction du degré de parallélisme
Le mode de fonctionnement classique d’un ordinateur consiste à exécuter un
programme séquentiellement. A tout instant du programme, une seule instruction,
portant sur une seule variable ou un couple de variables, est exécutée. Si le traitement
comporte plusieurs opérations, celles-ci doivent être effectuées séquentiellement, une
opération ne pouvant commencer que lorsque la précédente est terminée. Une telle
machine nécessite un seul processeur, un compteur d'instructions et une mémoire
contenant, à la fois, les données et les instructions, abstraction faite des
entrées/sorties. On donne à ce type d'architecture le nom de SISD : Single Instruction
Single Data stream (une seule instruction, une seule donnée).
Pour accélérer le traitement, une solution consiste à le répartir sur plusieurs
processeurs. Il y a différentes façons de procéder. La plus simple, équivalent au
49
Architecture des ordinateurs Gérard Dray – Ecole des Mines d'Alès
travail à la chaîne dans les usines, consiste à répartir, sur différents processeurs, le
traitement portant sur une donnée :
• Recherche de l'instruction en mémoire
• Décodage de l'instruction
• Calcul de l'adresse de la donnée
• Recherche de la donnée en mémoire exécution de l'instruction sur la donnée
• Rangement de la donnée transformée en mémoire
Une telle structure, dite MISD, Multiple Instruction Single Data stream, est plus
connue sous le nom de "pipe-line", par analogie avec les canalisations où le
carburant liquide entre, s'écoule et ressort à la sortie. Ce type d'architecture permet de
multiplier la capacité de traitement par le nombre de processeurs mis bout à bout, une
fois la chaîne amorcée. L'avantage de cette structure par rapport à la SISD est qu'elle
ne nécessite que peu d'accès à la mémoire, sachant que cette phase du traitement
représente de 80 à 90 % du temps d'occupation du processeur.
A l'inverse, il est souvent avantageux de faire effectuer simultanément la même
instruction sur des données différentes : on peut alors parler d'architecture parallèle.
Dans ce cas de figure, les données sont intrinsèquement structurées en ensemble
ordonnées et homogènes appelés "vecteurs", destinés à subir le même traitement.
Toutes ces données arrivent simultanément dans un ensemble de processeurs
élémentaires, dit "processeur vectoriel", où elles sont traitées en même temps selon
une instruction unique. L'ensemble des processeurs élémentaires est coordonné par
un superviseur. Ce parallélisme vectoriel est également appelé SIMD : Single
Instruction Multiple Data stream (une instruction, plusieurs données).
Le quatrième grand type d'architecture, dit parallélisme concurrent ou asynchrone,
encore désigné par MIMD - Multiple Instruction Data stream (instructions multiples,
données multiples) - se rencontre dans les problèmes décomposables en fonctions,
pouvant travailler simultanément sur des ensembles distincts de données, tels que les
méthodes de résolutions de systèmes d'équations par éléments finis. Plusieurs
instructions différentes, portant chacune sur une donnée ou un groupe de données,
sont exécutées indépendamment l'une de l'autre.
50
Architecture des ordinateurs Gérard Dray – Ecole des Mines d'Alès
5.3.2. Performances des microprocesseurs
Les performances des microprocesseurs se mesurent au nombre d'instructions qu'ils
peuvent exécuter en une seconde. Exemple : 80 MiPs = 80 millions d'instructions par
seconde. Cette valeur devrait être identique à la valeur de la fréquence de base du
microprocesseur, mais celui-ci n'exécute pas toujours une instruction par cycle. Pour
certaines instructions, il peut avoir besoin de 2 à 6 cycles, c'est pourquoi le nombre
de Mips est souvent inférieur au nombre de MHz. En utilisant des techniques de
traitement parallèle certains microprocesseurs peuvent offrir des performances en
Mips égales ou supérieures à leur fréquence d'horloge. Le flop est une unité de
performance appliquée aux ordinateurs scientifiques dédiés au calcul numérique.
Ceux-ci indiquent leur puissance de travail en Flops (Floating Point Operations per
Second ou nombre d'opérations en virgule flottante par seconde). On parle plus
exactement de Mflops (mégaflops) ou Gflops (Gigaflops).
5.3.3. Caractéristiques des mémoires
Technologies des mémoires :
On différencie 3 grandes familles de mémoires suivant le procédé physique utilisé
pour réaliser un point mémoire.
• Les mémoires magnétiques (disquette, disque dur, bande)
• Les mémoires optiques (CDROM, DVD)
• Les mémoires à semi-conducteurs (RAM, ROM)
On différencie deux types de mémoires à semi-conducteurs : les mémoires
statiques : très rapides mais très chères à fabriquer et les mémoires
dynamiques : moins rapides mais plus facilement intégrables. Les mémoires
dynamiques contiennent des capacités dont les charges doivent être
rafraîchies régulièrement, ce qui explique leur relative lenteur
Mode d’accès
Il existe différents types d’accès suivant les fonctions mémoire désirées:
51
Architecture des ordinateurs Gérard Dray – Ecole des Mines d'Alès
• Accès séquentiel : Pour accéder à l’information, il faut parcourir toutes celles
qui la précèdent (bande magnétique).
• Accès direct : L’information possède une adresse propre qui permet de la
localiser directement (RAM, ROM).
• Accès semi-séquentiel : C’est une combinaison entre l’accès direct et l’accès
séquentiel (Disque dur).
Volatilité
Une mémoire qui nécessite une source d’énergie pour conserver l’information est
dite volatile, c’est le cas des mémoires RAM. A contrario, les mémoires non-
volatiles peuvent conserver une information même sans être alimentées (ROM,
disque, cd)
Rapidité
On peut classer les mémoires en fonction de la durée d’accès à l’information
• Registres du CPU : Ils servent au stockage des opérandes et des résultats
intermédiaires (temps d’accès ≈ 5ns).
• Mémoire cache : Elle sert de tampon entre le CPU et la mémoire centrale
(temps d’accès ≈ 15 ns).
• Mémoire centrale : Elle est utilisée pour le rangement des informations; Elle
contient le programme à exécuter (temps d’accès ≈ 60 ns).
• Mémoire de masse : Ce sont tous les systèmes d’archivage comme le disque
dur, la bande magnétique, etc. (temps d’accès ≈ 10-30 ms).
5.3.4. Organisation et gestion des mémoires
L’ordinateur idéal possède une mémoire principale de taille infinie et aussi rapide
que son microprocesseur, mais les réalités technologiques et économiques sont toutes
autres. Un microprocesseur travaille 10 fois plus vite que sa mémoire principale et le
coût des mémoires à semi-conducteurs reste trop élevé pour imaginer en disposer en
quantité importante.
Comment palier ces problèmes de rapidité et de capacité de mémoire ?
52
Architecture des ordinateurs Gérard Dray – Ecole des Mines d'Alès
Une solution technologique pour la rapidité : les mémoires caches
Une solution logicielle pour la taille : la mémoire virtuelle
Mémoire cache
Le principe est de placer en tampon, entre le microprocesseur et la mémoire
principale, une mémoire rapide de petite capacité. Le microprocesseur a alors
l’impression de ne dialoguer qu’avec cette mémoire très rapide.
Mémoire virtuelle
Le principe est de réserver une zone de la mémoire de masse qui sera utilisée comme
une mémoire principale. Le système d’exploitation charge dans la mémoire
principale les blocs d’adresses nécessaires et sauvegarde sur le disque les blocs les
moins utilisés.
5.3.5. Entrées sorties
Elles permettent de transférer des informations entre l’unité centrale et les
périphériques qui composent l’ordinateur. Le dispositif le plus couramment utilisé
pour effectuer ces échanges est le bus. Comme nous l’avons déjà vu, le bus n'est rien
d'autre qu'un simple câble de n lignes qui permet de véhiculer des informations
binaires. Le bus permet de véhiculer tous les signaux entre l’Unité Centrale et les
périphériques. On peut le décomposer en trois grands groupes principaux qui sont :
• Le bus de données qui sert à transporter l’information proprement (32 à 64 bits).
• Le bus d’adresse qui permet d’identifier la case mémoire concernée par
l’opération en cours (32 à 64 bits).
• Le bus de commande qui détermine le type d’opération à effectuer (lecture,
écriture, sélection du composant, etc..).
En regard des vitesses de fonctionnement des processeurs actuels, celle des
périphériques est bien inférieure. C’est pourquoi le bus est divisé au moins en trois
sections ; l’une rapide dessert l’intérieur de l’Unité Centrale (mémoire cache,...), la
seconde, appelée bus local interface les périphériques du voisinage immédiat (vidéo,
disque dur, ..) et la dernière connecte les périphériques les plus lents (carte son,
clavier, ...).
53
Architecture des ordinateurs Gérard Dray – Ecole des Mines d'Alès
6. SOLUTIONS DES EXERCICES
54
Architecture des ordinateurs Gérard Dray – Ecole des Mines d'Alès
(ARCHIE01A)
a) Développez les notations et résoudre les équations obtenues :
( )0
01
11n
1nn
nb011nn bdbd...bdbddd...dd ×+×+×+×= −−−
b) Transcodez directement les nombres en utilisant les tables 2 et 3
c) Pour le nombre A utilisez la Table 3.
Pour le nombre B il faut réaliser des divisions successives par 16 et conserver les
restes.
d) Pour le nombre A utilisez la Table 2.
Pour le nombre B il faut réaliser des divisions successives par 8 et conserver les
restes.
55
Architecture des ordinateurs Gérard Dray – Ecole des Mines d'Alès
(ARCHIE01A)
a) ( ) ( ) ( )bbb 1022 =+
0100 b0b1b2b2 ×+×=×+×
4bb22
==+
( ) ( ) ( )bbb 1198594 =+
le)hexadécima (base 16bbb16
9bb9b179bb5b84b9
b9b1b1b5b8b4b9
2
2
2
0120101
==
++=+
++=+++
×+×+×=×+×+×+×
b) ( ) ( )216 1001 1010ACA ==
( ) ( )28 011 11065B ==
c) ( ) ( ) ( )1622 C11100 000111100A ===
( )10231B =
( )167EB1416014
71614231=
⎭⎬⎫
+×=+×=
d) ( ) ( ) ( )822 34100 01111100A ===
( )10231B =
( )8347B3803
483287828231
=⎪⎭
⎪⎬
⎫
+×=+×=+×=
56
Architecture des ordinateurs Gérard Dray – Ecole des Mines d'Alès
(ARCHIE02A)
a) En binaire naturel on utilise la conversion de la base binaire en base décimale
en appliquant la formule :
( )
( )( ) m
m1m
1m2
21
10
01
11n
1nn
n
bm1m21011nn
bdbd...bdbdbdbd...bdbd
dd...dd , dd...ddA−
−−−
−−−
−−
−−
−
−−−−
×+×+×+×+×+×+×+×=
=
En complément à un :
• Si le nombre commence par 0 alors le nombre est positif et on applique la même
règle qu'en binaire naturel.
• Si le nombre commence par 1, alors le nombre et négatif et pour trouver sa valeur
absolue on complémente bit à bit et on applique la même formule qu'en binaire
naturel.
En complément à deux :
• Si le nombre commence par 0 alors le nombre est positif et on applique la même
règle qu'en binaire naturel.
• Si le nombre commence par 1, alors le nombre et négatif et pour trouver sa valeur
absolue on complémente bit à bit, puis on additionne 1, et enfin et on applique la
même formule qu'en binaire naturel.
b) Il faut d'abord convertir la valeur absolue des nombres en binaire naturel.
Puis il faut choisir un nombre de bits approprié : ( ) ( )12 N 2- 1-p1-p −+≤≤
• Si le nombre est positif alors on utilise le code binaire naturel pour coder sur
p bits le nombre.
• Si le nombre est négatif, on utilise le code binaire naturel pour coder sur p la
valeur absolue du nombre, puis on complémente bit à bit et on ajoute 1
57
Architecture des ordinateurs Gérard Dray – Ecole des Mines d'Alès
(ARCHIE02A)
a)
( )
( )
( )
( ) 12412412401111100D4325211111100C
10310310301100111B191823711101101A
deux à Complémentun à ComplémentNaturel Binaire
2
2
2
2
+++=−−+=+++=−−+=
b) ( ) ( )2c10 01100100100A =+=
( ) ( )2c10 10011100100B =−=
58
Architecture des ordinateurs Gérard Dray – Ecole des Mines d'Alès
(ARCHIE03A)
Pour les deux nombres :
• Convertir le nombre en binaire
• Exprimer en binaire la mantisse (en conservant un 1 avant la virgule) et
l'exposant
• Coder le signe
• Coder l'exposant avec excès
• Coder la mantisse
59
Architecture des ordinateurs Gérard Dray – Ecole des Mines d'Alès
(ARCHIE03A)
( ) ( ) ( )( )
( )
( ) ( ) ( )
( )
( )précision simple IEEE
2
excès22
2
211
210
00000000000001110000001100000100A00111 :implicitebit un avec mantisse code
00111,1:mantisse10000010111111111 :excès avecexposant code
11 :exposant 1 code négatif:signe
1000111,111,100175,9A
=
=+
×−=−=−=
( ) ( ) ( )( )
( )
( ) ( ) ( )
( )
( )précision simple IEEE
2
excès22
2
211
210
000000000000010000000000011111000B01 :implicitebit un avec mantisse code
01,1:mantisse01111100111111111- :excès avecexposant code
11- :exposant 0 code positif:signe
1001,100101,015625,0B
=
=+
×−=+=+= −
60
Architecture des ordinateurs Gérard Dray – Ecole des Mines d'Alès
(ARCHIE04A)
Il n'existe pas de méthode systématique pour démontrer ces égalités.
A vous de jouer avec les axiomes de base …
61
Architecture des ordinateurs Gérard Dray – Ecole des Mines d'Alès
(ARCHIE04A)
a) bab.aa +=+
En partant : de b.aa +
Axiome 8b : ( )( )ba.aab.aa ++=+
Axiome 4a : ( )( ) ( )ba.1ba.aa +=++
Axiome 1b : ( ) baba.1 +=+
C.Q.F.D.
b) ( ) aba.a =+
En partant de : ( )ba.a +
Axiome 1a : ( ) ( )( )ba0aba.a ++=+
Axiome 8b : ( )( ) b.0aba0a +=++
Axiome 8b : ( )( ) b.0aba0a +=++
Axiome 2b : 0ab.0a +=+
Axiome 1a : a0a =+
C.Q.F.D.
c) x.bx.ab.ax.bx.a +=++
En partant de : b.ax.bx.a ++
Axiome 1b : 1.b.ax.bx.ab.ax.bx.a ++=++
Axiome 4a : ( )xx.b.ax.bx.a1.b.ax.bx.a +++=++
Axiome 8a : ( ) x.b.ax.b.ax.bx.axx.b.ax.bx.a +++=+++
Axiome 8a : ( ) ( )a1.x.bb1.x.ax.b.ax.b.ax.bx.a +++=+++
Axiome 2a : ( ) ( ) 1.x.b1.x.aa1.x.bb1.x.a +=+++
Axiome 1b : x.bx.a1.x.b1.x.a +=+
C.Q.F.D.
62
Architecture des ordinateurs Gérard Dray – Ecole des Mines d'Alès
(ARCHIE05A)
Décomposer l'expression en éléments de base. Par exemple pour exprimer dans
l'ordre :
1f
c.ad.c
c.ad.c
d
+
63
Architecture des ordinateurs Gérard Dray – Ecole des Mines d'Alès
(ARCHIE05A)
a)
101000001111101001000111000000001011000001000011110000101101100101100101000000101001000001100001000000011110100011010110000000011010000001010010000000111100100011110100000000111000000001110000fd.c.b.ac.b.ad.c.b.ad.c.adbadcba 2
b)
11001111111101110000101100010011110011011111010100001001000100010000111010110110000010100001001000001100101101000000100000010000fc.ad.cddcba 1
Les tables de vérité sont équivalentes, les expressions f1 et f2 sont donc égales
64
Architecture des ordinateurs Gérard Dray – Ecole des Mines d'Alès
(ARCHIE06A)
Effectuez les additions en utilisant la Table 9.
En binaire naturel le résultat est correct sur 8 bits si aucune retenue n'est générée.
En complément à deux il faut ignorer la retenue et vérifier si le signe du résultat est
correct sur 8 bits.
65
Architecture des ordinateurs Gérard Dray – Ecole des Mines d'Alès
(ARCHIE06A)
0010101011110011010110111
11110111
SBA
Retenues
1
+
Retenue générée En binaire naturel le résultat est faux sur 8 bits
En complément à deux le résultat est correct sur 8 bits
1001011110011111110110111
00111111
SCA
Retenues
2
+
Retenue générée En binaire naturel le résultat est faux sur 8 bits
En complément à deux le résultat est correct sur 8 bits
110001110011111011100110
0011111
SDB
Retenues
3
+
En binaire naturel le résultat est correct sur 8 bits
En complément à deux le résultat est faux sur 8 bits
66
Architecture des ordinateurs Gérard Dray – Ecole des Mines d'Alès
1. En vous servant de la table 15 vous pouvez décoder le programme contenu de l'adresse
%0000 à l'adresse %1000.
Adresse
%0000 LDA %1101%0010 ADD %1111%0100 DEC %1110%0110 BZ0 %0010%1000 BR %1000
Instruction
2. En suivant l'exemple des §5.2.4 et §5.2.5 vous pouvez retrouver la trace d'exécution
suivante :
Instruction LDA %1101
Phase de recherche de l'instruction en mémoireCycle 1 [RA] <= [CO] { SBCO, SRA } RA = %0000Cycle 2 [RI1] <= [M(RA)] { SBRA, L, SRI1 } RI1 = %1000Cycle 2 [CO] <= [CO]+1 { CO+1 } C0 = %0001Cycle 3 [RA] <= [CO] { SBCO, SRA } RA = %0001Cycle 4 [RI2] <= [M(RA)] { SBRA, L, SRI1 } RI2 = %1101
Phase d'exécution de l'instructionCycle 5 [RA] <= [RI2] { SBRI2, SRA } RA = %1101Cycle 6 [ACCCU] <= [M(RA)] { SBRA, L, SACCU } ACCU = %0100
Phase de préparation de l'instruction suivanteCycle 6 [CO] <= [CO]+1 { CO+1 } CO = %0010
Instruction ADD %1111
Phase de recherche de l'instruction en mémoireCycle 1 [RA] <= [CO] { SBCO, SRA } RA = %0010Cycle 2 [RI1] <= [M(RA)] { SBRA, L, SRI1 } RI1 = %0110Cycle 2 [CO] <= [CO]+1 { CO+1 } C0 = %0011Cycle 3 [RA] <= [CO] { SBCO, SRA } RA = %0011Cycle 4 [RI2] <= [M(RA)] { SBRA, L, SRI1 } RI2 = %1111
Phase d'exécution de l'instructionCycle 5 [R1] <= [ACCU] { SR1 } R1 = %0100Cycle 5 [RA] <= [RI2] { SBRI2, SRA } RA = %1111Cycle 6 [R2] <= [M(RA)] { SBRA, L, SR2 } R2 = %0000Cycle 7 [R3] <= [R1] + [R2] { COP=%110, SR3 } R3 = %0100Cycle 7 [RE] <= C,Z RE = %00Cycle 8 [M(RA)] <= [R3] { SBR3, SBRA, E } [M(%1111)] = %0100
Phase de préparation de l'instruction suivanteCycle 8 [CO] <= [CO]+1 { CO+1 } CO = %0100
67
Architecture des ordinateurs Gérard Dray – Ecole des Mines d'Alès
Instruction DEC %1110
Phase de recherche de l'instruction en mémoireCycle 1 [RA] <= [CO] { SBCO, SRA } RA = %0100Cycle 2 [RI1] <= [M(RA)] { SBRA, L, SRI1 } RI1 = %0010Cycle 2 [CO] <= [CO]+1 { CO+1 } C0 = %0101Cycle 3 [RA] <= [CO] { SBCO, SRA } RA = %0101Cycle 4 [RI2] <= [M(RA)] { SBRA, L, SRI1 } RI2 = %1110
Phase d'exécution de l'instructionCycle 5 [RA] <= [RI2] { SBRI2, SRA } RA = %1110Cycle 6 [R2] <= [M(RA)] { SBRA, L, SR2 } R2 = %0011Cycle 7 [R3] <= [R2] - 1 { COP=%010, SR3 } R3 = %0010Cycle 7 [RE] <= C,Z RE = %00Cycle 8 [M(RA)] <= [R3] { SBR3, SBRA, E } [M(%1110)] = %0010
Phase de préparation de l'instruction suivanteCycle 8 [CO] <= [CO]+1 { CO+1 } CO = %0110
Instruction BZ0 %0010
Phase de recherche de l'instruction en mémoireCycle 1 [RA] <= [CO] { SBCO, SRA } RA = %0110Cycle 2 [RI1] <= [M(RA)] { SBRA, L, SRI1 } RI1 = %1110Cycle 2 [CO] <= [CO]+1 { CO+1 } C0 = %0111Cycle 3 [RA] <= [CO] { SBCO, SRA } RA = %0111Cycle 4 [RI2] <= [M(RA)] { SBRA, L, SRI1 } RI2 = %0010
Phase d'exécution de l'instructionCycle 5 [CO] <= [RI2] { SBRI2, SCO } CO = %0010Le test est vrai (Z=0, cf. cycle 7 de l'instruction pécédente) donc CO reçoit l'adresse de branchementPhase de préparation de l'instruction suivanteInstruction de branchement - Cette phase est vide
Instruction ADD %1111
Phase de recherche de l'instruction en mémoireCycle 1 [RA] <= [CO] { SBCO, SRA } RA = %0010Cycle 2 [RI1] <= [M(RA)] { SBRA, L, SRI1 } RI1 = %0110Cycle 2 [CO] <= [CO]+1 { CO+1 } C0 = %0011Cycle 3 [RA] <= [CO] { SBCO, SRA } RA = %0011Cycle 4 [RI2] <= [M(RA)] { SBRA, L, SRI1 } RI2 = %1111
Phase d'exécution de l'instructionCycle 5 [R1] <= [ACCU] { SR1 } R1 = %0100Cycle 5 [RA] <= [RI2] { SBRI2, SRA } RA = %1111Cycle 6 [R2] <= [M(RA)] { SBRA, L, SR2 } R2 = %0100Cycle 7 [R3] <= [R1] + [R2] { COP=%110, SR3 } R3 = %1000Cycle 7 [RE] <= C,Z RE = %00Cycle 8 [M(RA)] <= [R3] { SBR3, SBRA, E } [M(%1111)] = %1000
Phase de préparation de l'instruction suivanteCycle 8 [CO] <= [CO]+1 { CO+1 } CO = %0100
Instruction DEC %1110
Phase de recherche de l'instruction en mémoireCycle 1 [RA] <= [CO] { SBCO, SRA } RA = %0100Cycle 2 [RI1] <= [M(RA)] { SBRA, L, SRI1 } RI1 = %0010Cycle 2 [CO] <= [CO]+1 { CO+1 } C0 = %0101Cycle 3 [RA] <= [CO] { SBCO, SRA } RA = %0101Cycle 4 [RI2] <= [M(RA)] { SBRA, L, SRI1 } RI2 = %1110
Phase d'exécution de l'instructionCycle 5 [RA] <= [RI2] { SBRI2, SRA } RA = %1110Cycle 6 [R2] <= [M(RA)] { SBRA, L, SR2 } R2 = %0010Cycle 7 [R3] <= [R2] - 1 { COP=%010, SR3 } R3 = %0001Cycle 7 [RE] <= C,Z RE = %00Cycle 8 [M(RA)] <= [R3] { SBR3, SBRA, E } [M(%1110)] = %0001
Phase de préparation de l'instruction suivanteCycle 8 [CO] <= [CO]+1 { CO+1 } CO = %0110
68
Architecture des ordinateurs Gérard Dray – Ecole des Mines d'Alès
Instruction BZ0 %0010
Phase de recherche de l'instruction en mémoireCycle 1 [RA] <= [CO] { SBCO, SRA } RA = %0110Cycle 2 [RI1] <= [M(RA)] { SBRA, L, SRI1 } RI1 = %1110Cycle 2 [CO] <= [CO]+1 { CO+1 } C0 = %0111Cycle 3 [RA] <= [CO] { SBCO, SRA } RA = %0111Cycle 4 [RI2] <= [M(RA)] { SBRA, L, SRI1 } RI2 = %0010
Phase d'exécution de l'instructionCycle 5 [CO] <= [RI2] { SBRI2, SCO } CO = %0010Le test est vrai (Z=0, cf. cycle 7 de l'instruction pécédente) donc CO reçoit l'adresse de branchementPhase de préparation de l'instruction suivanteInstruction de branchement - Cette phase est vide
Instruction ADD %1111
Phase de recherche de l'instruction en mémoireCycle 1 [RA] <= [CO] { SBCO, SRA } RA = %0010Cycle 2 [RI1] <= [M(RA)] { SBRA, L, SRI1 } RI1 = %0110Cycle 2 [CO] <= [CO]+1 { CO+1 } C0 = %0011Cycle 3 [RA] <= [CO] { SBCO, SRA } RA = %0011Cycle 4 [RI2] <= [M(RA)] { SBRA, L, SRI1 } RI2 = %1111
Phase d'exécution de l'instructionCycle 5 [R1] <= [ACCU] { SR1 } R1 = %0100Cycle 5 [RA] <= [RI2] { SBRI2, SRA } RA = %1111Cycle 6 [R2] <= [M(RA)] { SBRA, L, SR2 } R2 = %1000Cycle 7 [R3] <= [R1] + [R2] { COP=%110, SR3 } R3 = %1100Cycle 7 [RE] <= C,Z RE = %00Cycle 8 [M(RA)] <= [R3] { SBR3, SBRA, E } [M(%1111)] = %1100
Phase de préparation de l'instruction suivanteCycle 8 [CO] <= [CO]+1 { CO+1 } CO = %0100
Instruction DEC %1110
Phase de recherche de l'instruction en mémoireCycle 1 [RA] <= [CO] { SBCO, SRA } RA = %0100Cycle 2 [RI1] <= [M(RA)] { SBRA, L, SRI1 } RI1 = %0010Cycle 2 [CO] <= [CO]+1 { CO+1 } C0 = %0101Cycle 3 [RA] <= [CO] { SBCO, SRA } RA = %0101Cycle 4 [RI2] <= [M(RA)] { SBRA, L, SRI1 } RI2 = %1110
Phase d'exécution de l'instructionCycle 5 [RA] <= [RI2] { SBRI2, SRA } RA = %1110Cycle 6 [R2] <= [M(RA)] { SBRA, L, SR2 } R2 = %0001Cycle 7 [R3] <= [R2] - 1 { COP=%010, SR3 } R3 = %0000Cycle 7 [RE] <= C,Z RE = %01Cycle 8 [M(RA)] <= [R3] { SBR3, SBRA, E } [M(%1110)] = %0000
Phase de préparation de l'instruction suivanteCycle 8 [CO] <= [CO]+1 { CO+1 } CO = %0110
Instruction BZ0 %0010
Phase de recherche de l'instruction en mémoireCycle 1 [RA] <= [CO] { SBCO, SRA } RA = %0110Cycle 2 [RI1] <= [M(RA)] { SBRA, L, SRI1 } RI1 = %1110Cycle 2 [CO] <= [CO]+1 { CO+1 } C0 = %0111Cycle 3 [RA] <= [CO] { SBCO, SRA } RA = %0111Cycle 4 [RI2] <= [M(RA)] { SBRA, L, SRI1 } RI2 = %0010
Phase d'exécution de l'instructionCycle 5 [CO] <= [CO]+1 { CO+1 } CO = %1000Le test est faux (Z=1, cf. cycle 7 de l'instruction précédente) donc CO reçoit l'adresse suivante : [CO] + 1Phase de préparation de l'instruction suivanteInstruction de branchement - Cette phase est vide
69
Architecture des ordinateurs Gérard Dray – Ecole des Mines d'Alès
Instruction BR %1000
Phase de recherche de l'instruction en mémoireCycle 1 [RA] <= [CO] { SBCO, SRA } RA = %1000Cycle 2 [RI1] <= [M(RA)] { SBRA, L, SRI1 } RI1 = %1011Cycle 2 [CO] <= [CO]+1 { CO+1 } C0 = %1001Cycle 3 [RA] <= [CO] { SBCO, SRA } RA = %1001Cycle 4 [RI2] <= [M(RA)] { SBRA, L, SRI1 } RI2 = %1000
Phase d'exécution de l'instructionCycle 5 [CO] <= [RI2] { SBRI2, SCO } CO = %1000
Phase de préparation de l'instruction suivanteInstruction de branchement - Cette phase est vide
Cette dernière instruction est exécutée indéfiniment.
Voici une trace du programme en ne considérant que les registres CO, ACCU et RE
ainsi que les adresses mémoire %1101, %1110 et %1111.
Les tirets (------------) indiquent que le contenu du registre ou de la case mémoire
n’est pas modifié.
L’effet d’une instruction est visible sur la ligne suivante. Par exemple à la ligne 5
l’effet de l’instruction pointée par CO (ADD %1111) est observable à la ligne
suivante.
[CO] [ACCU] [M(%1101)] [M(%1110)] [M(%1111)] RE(C,Z)
%0000 %XXXX %0100 %0011 %0000 %XX LDA %1101 [ACCU] <= [M(ADR)]%0010 %0100 ----------- ----------- ----------- ----------- ADD %1111 [M(ADR)] <= [ACCU] + [M(ADR)]%0100 ----------- ----------- ----------- %0100 %00 DEC %1110 [M(ADR)] <= [M(ADR)] - 1%0110 ----------- ----------- %0010 ----------- %00 BZ0 %0010 [CO] <= ADR Si Z=0%0010 ----------- ----------- ----------- ----------- ----------- ADD %1111 [M(ADR)] <= [ACCU] + [M(ADR)]%0100 ----------- ----------- ----------- %1000 %00 DEC %1110 [M(ADR)] <= [M(ADR)] - 1%0110 ----------- ----------- %0001 ----------- %00 BZ0 %0010 [CO] <= ADR Si Z=0%0010 ----------- ----------- ----------- ----------- ----------- ADD %1111 [M(ADR)] <= [ACCU] + [M(ADR)]%0100 ----------- ----------- ----------- %1100 %00 DEC %1110 [M(ADR)] <= [M(ADR)] - 1%0110 ----------- ----------- %0000 ----------- %01 BZ0 %0010 [CO] <= ADR Si Z=0%1000 ----------- ----------- ----------- ----------- ----------- BR %1000 [CO] <= ADR%1000 ----------- ----------- ----------- ----------- ----------- BR %1000 [CO] <= ADR%1000 ----------- ----------- ----------- ----------- ----------- BR %1000 [CO] <= ADR. . . . . . . . . . . .. . . . . . . . . . . .. . . . . . . . . . . .
Instructions Opérations
Le programme réalise la fonction suivante : [M(%1111)] <= [M(%1101)] *
[M(%1110)] en effectuant des additions successives.
A la fin du programme : [M(%1111)] = [M(%1101)] + [M(%1101)] + [M(%1101)] =
3 fois [M(%1101)] = [M(%1101)] * [M(%1110)] = 3 fois 4 = 12 = %1100.
70