ARCHITECTURE DES ORDINATEURS IG3 2012-2013

TD 1 : Représentation et encodage de l'information

Clément Jonquet

{jonquet@lirmm.fr}

Représentation des entiers

Question 1
Quelles valeurs numériques décimales faites-vous correspondre à la valeur binaire 1111 1111
contenue dans un mot mémoire de 8 bits, en :
(a) représentation normale
1∗27 +1∗26 +1∗25 +1∗24 +1∗23 +1∗22 +1∗21 +1∗20 = 128+64+32+16+8+4+2+1 =
255
(b) valeur absolue signée
Le bit de poids fort indique le signe (signe + = 0 , signe - = 1)
1 → −1∗26 +1∗25 +1∗24 +1∗23 +1∗22 +1∗21 +1∗20 = 64+32+16+8+4+2+1 = −127
(c) complément à 1
Le bit de poids fort indique le signe (signe + = 0 , signe - = 1)
Complément à 1 de 111 1111 → 000 0000
1 → −0 ∗ 26 + 0 ∗ 25 + 0 ∗ 24 + 0 ∗ 23 + 0 ∗ 22 + 0 ∗ 21 + 0 ∗ 20 = −0
(d) complément à 2
Le bit de poids fort indique le signe (signe + = 0 , signe - = 1)
On ajoute 1 au complément à 1 → 000 0001
1 → −0 ∗ 26 + 0 ∗ 25 + 0 ∗ 24 + 0 ∗ 23 + 0 ∗ 22 + 0 ∗ 21 + 1 ∗ 20 = −1
Question 2
Une manière plus pratique de représenter les nombres binaires est d'utiliser des bases qui
sont des puissances de 2. Ainsi, on utilise souvent la base 16 (hexadécimal) qui comporte les
chires 0, 1 ,2 ,3 ,4, 5 ,6 ,7 ,8 ,9 ,A ,B ,C ,D ,E ,F.
(a) Combien de chires en hexadécimal faut-il pour coder un octet ?
1 octet = 8 bits ⇒ 28 = 256 possibilités.
log16 (256) = log16 (162 ) = 2 Il faut donc 2 chires hexadécimaux pour représenter 256
possibilités.

(b) Quels nombres décimal et binaire le nombre hexadécimal 7FFF FFFA représente-t-il ?
Décimal :
7 ∗ 167 + 15 ∗ 166 + 15 ∗ 165 + 15 ∗ 164 + 15 ∗ 163 + 15 ∗ 162 + 15 ∗ 161 + 10 ∗ 160 =
7 ∗ 268435456 + 15 ∗ 16777216 + 15 ∗ 1048576 + 15 ∗ 65536 + 15 ∗ 4096 + 15 ∗ 256 +
15 ∗ 16 + 10 ∗ 1
= 1879048192 + 251658240 + 15728640 + 983040 + 61440 + 3840 + 240 + 10
= 2147483642
 Binaire :
7 F F F F F F A
0111 1111 1111 1111 1111 1111 1111 1010

(c) Quel nombre hexadécimal représente le nombre binaire suivant ?

1100 1010 1111 1110 1111 1010 1100 1110

1100 1010 1111 1110 1111 1010 1100 1110

C A F E F A C E

Question 3
Donner sur 8 bits les représentations des nombres -32, -127 et -128 dans les systèmes de
représentation suivants : valeur absolue signée, complément à 1, complément à 2.

-32 -127 -128

valeur absolue signée 1010 0000 1111 1111 ∅ (-127 max !)
complément à 1 1101 1111 1000 0000 ∅ (-127 max !)
complément à 2 1110 0000 1000 0001 1000 0000

Question 4
Représenter les nombres décimaux 512, -1023 et -25000 en binaire en utilisant la représen-
tation en complément à 2 sur 16 bits.

Le complément à 2 d'un nombre binaire positif est ce nombre.

512 = 29 ⇒ 10eme bit à 1 et on complète avec des 0 jusqu'a 32 bits.
= 0000 0010 0000 0000
Le complément à 2 d'un nombre binaire négatif est le complément à 1 de la valeur ab-
solue de ce nombre, plus 1.
1023 = (1024 − 1) et 1024 = 210 ⇒ 10 premiers bits sont à 1.
= 0000 0011 1111 1111
−1023 = C1 (1023) + 1 = 1111 1100 0000 0000 + 1
= 1111 1100 0000 0001

25000 = 0110 0001 1010 1000 ⇒ Par divisions successives de 2.

−25000 = C1 (25000) + 1 = 1001 1110 0101 0111 + 1
= 1001 1110 0101 1000

Question 5
Quels nombres décimaux représentent les nombres binaires en complément à 2 suivants ?
(a) 1111 1110 0000 1100
Lorsque le bit de poids fort est un 1 cela indique un nombre négatif, il faut donc faire
l'opération de conversion inverse pour obtenir le nombre d'origine : soustraire 1 →
complément à 1 → conversion décimale.
1111 1110 0000 1100 − 1 = 1111 1110 0000 1011 → 0000 0001 1111 0100 → −(256 +
128 + 64 + 32 + 16 + 4) = −500

(b) 1111 1111 1111 1111

1111 1111 1111 1111 − 1 = 1111 1111 1111 1110 → 0000 0000 0000 0001 → −1
(c) 0000 1111 1111 1111

2
 Lorsque le bit de poids fort est un 0 cela indique un nombre positif, le nombre est donc
équivalent à sa valeur décimale.
0000 1111 1111 1111 = 4095

Représentation des nombres réels

Question 6
Donner en binaire et en hexadécimal la représentation en virgule xe (8 bits de partie entière
+ 4 bits de partie décimale "binaire") des nombres décimaux suivants :
(a) 0.3125
Les bits à droite de la virgule représentent la partie décimale "binaire" du nombre
et correspondent à l'inverse des puissances de 2. La conversion de la partie décimale
"binaire" se fait par des multiplications successives par 2.
0.3165 ∗ 2 = 0.625
0.625 ∗ 2 = 1.25
0.25 ∗ 2 = 0.5
0.5 ∗ 2 = 1.0
Binaire :
⇒ 0.3165 = 0000 0000.0101 = 0 ∗ 2−1 + 1 ∗ 2−2 + 0 ∗ 2−3 + 1 ∗ 2−4
= 0 ∗ 0.5 + 1 ∗ 0.25 + 0 ∗ 0.125 + 1 ∗ 0.0625
Hexadécimal :
⇒ 0.3165 = 00.5
(b) 32.625
Binaire :
⇒ 32.625 = 0010 0000.1010
Hexadécimal :
⇒ 32.625 = 20.A
(c) 128.2
Binaire :
⇒ 128.2 ≈ 1000 0000.0011 = 128.1875 4 bits n'ore qu'une très petite précision.
Hexadécimal :
⇒ 128.2 = 80.3
Question 7
Quel nombre décimal est représenté par la chaîne de bits suivante, codée en représentation
ottante IEEE 754 en simple précision (i.e., 1 bit de signe, 8 bits d'exposant, 23 bits de
mantisse) :
1100 0001 1011 0001 0000 0000 0000 0000

n−1 −1)
Représentation IEEE 754 : x = (−1)S × (1, M ) × 2E−(2
8−1 −1)
⇒ (−1)1 × (1, 011 0001 0000 0000 0000 0000) × 2100 0001 1−(2
= −1 × 1, (0.25 + 0.125 + 0.0078125) × 2131−127
= −1, 3828125 × 24
= −1, 3828125 × 16
= −22, 125

3
Question 8
Donnez la représentation ottante IEEE 754 en simple précision des nombres rationnels
suivants : 10, 10.5 et 0.1

10 → 1010 = 1.010 × 23
S = 0 (le nombre est positif)
M = 010, soit 010 0000 0000 0000 0000 0000 sur 23 bits.
E = 3+127 = 130 = 1000 0010 sur 8 bits
Soit 0100 0001 0010 0000 0000 0000 0000 0000

10.5 → 1010.1 = 1.0101 × 23

S = 0 (le nombre est positif)
M = 0101, soit 010 1000 0000 0000 0000 0000 sur 23 bits.
E = 3+127 = 130 = 1000 0010 sur 8 bits
Soit 0100 0001 0010 1000 0000 0000 0000 0000

0.1 ∗ 2 = 0, 2
0.2 ∗ 2 = 0, 4
0.4 ∗ 2 = 0, 8
0.8 ∗ 2 = 1, 6
0.6 ∗ 2 = 1, 2
0.2 ∗ 2 = 0, 4
0.4 ∗ 2 = 0, 8
. . . ⇒ On boucle, il n'y a donc pas de représentation exacte du nombre 0.1. On doit donc
tronquer en fonction de la taille de la mantisse (i.e., 23 bits)
⇒ 0.1 ≈ 000 1100 1100 1100 1100 1100 ≈ 1.100 1100 1100 1100 1100 1100 × 2−4
S = 0 (le nombre est positif)
M = 100 1100 1100 1100 1100 1100
E = -4+127 = 123 = 0111 1011 sur 8 bits
Soit 0011 1101 1100 1100 1100 1100 1100 1100 ≈ 0.099999994

Opérations arithmétiques en binaire

Question 9
Eectuer les opérations arithmétiques suivantes en supposant que les nombres sont repré-
sentés en codage normal (entier positif) :
(a) 128 + 15

1 0 0 0 0 0 0 0 (128)
+ 0 0 0 0 1 1 1 1 (15)
1 0 0 0 1 1 1 1 (143)

(b) 234 + 65
1 11 1 1 0 1 0 1 0 (234)
+ 0 1 0 0 0 0 0 1 (65)
1 0 0 1 0 1 0 1 1 (299)
Cet exemple illustre un dépassement de capacité si la taille de représentation des
nombres était limitée à 8 bits. Il illustre également le report de la retenue.

(c) 70 − 20

4
 0 10 01 10 0 1 1 0 (70)
− 0 0 0 1 0 1 0 0 (20)
0 0 1 1 0 0 1 0 (50)

(d) 13 × 5

1 1 0 1 (13)
* 1 0 1 (5)
1 1 1 11 1 0 1
0 0 0 0 0
1 1 0 1 0 0
1 0 0 0 0 0 1 (65)
Cet exemple illustre également un dépassement de capacité si la taille de représentation
des nombres était limitée à 4 bits.
(e) 356/4

1 0 1 1 0 0 1 0 0
/ 1 0 0
1 0 1 1 0 0 1
A dérouler !
(f) 234/13

1 1 1 0 1 0 1 0 (234)
/ 1 1 0 1 (13)
1 0 0 1 0 (18)
A dérouler !
Question 10
Eectuer les opérations arithmétiques suivantes en supposant que les nombres sont repré-
sentés en complément à 2 sur 8 bits :
(a) 70 − 20
1 01 1 0 01 01 1 1 0 (70)
+ 1 1 1 0 1 1 0 0 (-20)
0 0 1 1 0 0 1 0 (50)
Le nombre positif est plus grand que le nombre négatif : addition binaire classique et
on 'oublie' la dernière retenue (à gauche). La somme est positive.

(b) 20 − 70

0 01 01 1 0 1 0 0 (20)
+ 1 0
1 1 1 1 0 1 0 (-70)
1 1 0 0 1 1 1 0 (-50)
Le nombre négatif est plus grand que le nombre positif : addition binaire classique, la
somme est négative et représentée directement dans le système complément à 2.

(c) −20 − 70
1 11 11 11 01 1 1 0 0 (-20)
+ 1 0 1 1 1 0 1 0 (-70)
1 0 1 0 0 1 1 0 (-90)
Les deux nombres sont négatifs : addition binaire classique et on oublie la dernière
retenue (à gauche). La somme est négative.

5
 Encodage
Question 11
Compléter en utilisant le contrôle de parité paire les octets suivants :
1 0 1 0 0 0 1
0 1 1 1 1 1 1

En parité paire, le nombre de bits à 1 doit être pair.

1 1 0 1 0 0 0 1
0 0 1 1 1 1 1 1

Question 12
Nous utilisons le codage suivant pour transférer des messages formés de caractères :
 Codage ASCII sur 7 bits pour les caractères.
 Contrôle de double parité paire avec 1 bit contrôle transversal sur le bit de poids fort.
 Contrôle longitudinal après 6 mots (y compris bit de poids fort).
Vous venez de recevoir le message suivant :
A B C D E F G H
1 1 1 0 0 1 1 0 0
2 0 1 1 0 0 1 0 1
3 1 0 1 0 0 0 0 0
4 1 1 0 1 0 0 0 0
5 0 1 1 1 0 0 1 0
6 0 1 1 0 1 1 1 1
7 1 1 1 0 0 1 0 0
8 0 1 1 0 0 1 1 0
9 1 0 1 0 0 0 0 0
10 0 1 1 0 0 1 0 1
11 1 1 1 1 0 0 1 1
12 0 1 1 1 0 1 0 0
13 1 0 1 0 0 1 0 0
14 1 0 0 0 0 1 0 0
15 1 1 1 1 0 0 1 1
16 1 1 1 1 0 1 0 1
17 1 1 1 1 0 0 0 0
18 0 1 1 0 0 1 0 1
19 1 1 1 1 0 0 1 0
20 0 0 1 0 0 0 0 1
21 1 1 0 0 0 0 0 0
Détecter et corriger, si nécessaire, les erreurs de transferts et décoder le message.
Indication : l'espace se représente 0100000 en ASCII.

 La détection des erreurs avec le double contrôle de parité nous indique des erreurs en :
C4, F13, A19.
 La correction des erreurs est possible sans retransmission car il y à qu'une seule erreur
par bloc de 7 mots.
 Le message décodé (en ignorant les lignes 7, 14 et 21 qui servent au contrôle longitudinal)
donne : "Le prof est super !"

Question 13
Proposer un codage de Human pour la phrase décodée de l'exercice précédent. Encoder

6
le message en utilisant ce codage et le même contrôle de double parité que précédemment.
Comparer la taille du nouveau message à précédemment. Commentez.

 Le calcul de la fréquence des caractères du message nous donne :

L e p r o f s t u !
1 3 3 2 2 1 1 2 1 1 1
 Construire un arbre binaire et en tirer un codage. Notez que ce codage dépend de l'étape
de construction de l'arbre binaire (i.e., des sommes réalisées) :
L 0 0 1 0
e 1 1 0
1 1 1
p 1 0 0
r 1 0 1
o 0 0 1 1
f 0 1 0 0
s 0 0 0
t 0 1 0 1
u 0 1 1 0
! 0 1 1 1
 Il s'agit maintenant de coder le message "Le prof est super !" avec ce nouveau codage :
0010110 1111001 0100110 1001111 1000001 0111100 0011010 0110101 0111
 Pour garantir l'auto-correction du message, on divise le message précèdent par mot de
7 bits (en complétant avec 1 espace "111") et on rajoute 1 bit de contrôle de parité
transversal sur le bit de poids fort. Tous les 6 octets (ou moins), on rajoute un octet de
contrôle longitudinal. Ce qui nous donne :
1 0 0 1 0 1 1 0
1 1 1 1 1 0 0 1
1 0 1 0 0 1 1 0
1 1 0 0 1 1 1 1
0 1 0 0 0 0 0 1
0 0 1 1 1 1 0 0
0 1 1 1 1 0 1 1
1 0 0 1 1 0 1 0
0 0 1 1 0 1 0 1
1 0 1 1 1 1 1 1
0 0 0 1 0 0 0 0
 La taille du nouveau message est donc bien plus courte 11 octets au lieu de 21. Notez
cependant qu'il aurait fallu spécier 1 caractère de n de message (au lieu d'utiliser
espace) et qu'il faudrait aussi considérer l'envoi du codage de Human utilisé pour coder
le message.