ppt, 233KB

Arithmétique des “computers”

Opérations arithmétiques sur les données (datapath)

Nombres entiers et flottants
MÉMOIRE
PRINCIPALE
DD IO
IO
BUS SYSTÈME
Cache
instructions
MMU
TLB
Unité de
contrôle
Unité de
traitement
ALU
Décodeur
CPU
Unité
flottante
PC
Registres
Cache
données
Multiplication - Nombres entiers
Multiplication de deux nombres entiers de n bits:
Décimal:
1000
1001
1000
0000
0000
1000
1001000
x
+
+
+
+
Note: résultat -> 2n bits!
Binaire:
1000
1001
1000
0000
0000
1000
1001000
x
(8)
(9)
+
+
+
+
(72)
Multiplication - Implémentation I
Début
A(n)
1 A[0] 0
B(2n)
PP+B
2n
B
A
1000
1001
1000
0000
0000
1000
1001000
x
+
+
+
+
Décaler A (droite)
+[2n]
Décaler B (gauche)
P (2n)
Fin? NO
Multiplication - Implémentation I
Début
1
A[0]
0
0
1001
00001000
PP+B
1
0100
00010000
2
0010
00100000
Décaler A >>
+
Décaler B <<
00001000
00000000
Fin? NO
B
A
1000
1001
1000
0000
0000
1000
1001000
x
3
0001
01000000
+
+
+
+
00001000
4
0000
10000000
+
01001000
00001000
01001000
00001000
Multiplication - Implémentation II
P+= moitié de poids
fort du registre P
Début
A(n)
1 A[0] 0
B(n)
P+  P+ + B
n
B
A
1000
1001
1000
0000
0000
1000
1001000
x
+
+
+
+
Décaler A (droite)
Décaler P (droite)
Fin? NO
+[n]
P (2n)
Multiplication - Implémentation II
Début
1
A[0]
0
0
Décaler A >>
0100
1000
2
0010
1000
+
Décaler P >>
1000
00000000
Fin? NO
1000
1001
1000
0000
0000
1000
1001000
1
1000
P+P++B
B
A
1001
x
3
0001
1000
+
+
+
+
01000000
4
0000
1000
+
1001
00010000
01001000
00100000
Multiplication - Implémentation III
P+= moitié de poids
fort du registre P
Début
1 A[0] 0
B(n)
P+  P+ + B
n
B
A
1000
1001
1000
0000
0000
1000
1001000
x
+
+
+
+
Décaler P|A (droite)
+[n]
P (2n)
Fin? NO
A(n)
Multiplication - Implémentation III
Début
1
A[0]
0
0
1
1000
P+P++B
2
1000
1000
Décaler P|A >>
+
1000
0000 1001
Fin? NO
B
A
1000
1001
1000
0000
0000
1000
1001000
x
3
4
1000
+
+
+
+
01000 100
1000
+
1001
0001000 1
01001000
001000 10
Multiplication - Nombres signés
Approche « standard »: convertir les nombres négatifs en
positifs, multiplier, convertir au négatif si les signes sont
différents.
Avantage: conceptuellement simple.
Désavantage: ressources supplémentaires.
Deuxième approche: recodage de Booth
Idée: abandonner l’algorithme décimal pour accélérer la
multiplication binaire, en particulier pour traiter les nombres
signés comme s’ils étaient non-signés.
Avantage: économe en ressources.
Désavantage: conceptuellement assez compliqué .
Multiplication - Recodage de Booth
Multiplication « standard »: examiner A de droite à gauche
A=7=0111
 add B, add B, add B, add 0
Recodage de Booth:
A=8-1=1000-0001=1001  sub B, add 0, add 0, add B
Standard:
Booth:
B
1011 x
B
1011
A
0111
A
1001
+
1011 (add)
1011
+
1011 (add)
+
0000
+ 1011
(add)
+ 0000
+ 0000
(shift)
+ 1011
1001101
1001101
Même chose pour le nombres signés:
x
(sub)
(shift)
(shift)
(add)
A = -4 = 1100
A = -4 = 1100 = 12 = 16 - 4 = 10000 - 0100 = 0100
Recodage de Booth en pratique
On observe deux bits de A, pour déterminer s’il s’agit du début, du milieu,
ou de la fin d’une séquence de 1 ou de 0:
- si Ai = 0 et Ai-1 = 0, décaler P (milieu d’une séquence de 0);
- si Ai = 0 et Ai-1 = 1, ajouter B à P (fin d’une séquence de 1);
- si Ai = 1 et Ai-1 = 0, soustraire B de P (début d’une séquence de 1);
- si Ai = 1 et Ai-1 = 1, décaler P (milieu d’une séquence de 1);
Par exemple:
A : 00011101

sub, add, sub, shift, shift, add, shift, shift
Rappel: soustraction = addition du complement à deux.
L’algorithme marche pour le nombres signés (attention quand-même:
l’algorithme « papier » doit être modifié pour étendre le signe).
L’implémentation est pratiquement identique à l’approche standard.
Multiplication - Recodage de Booth
Début
1
0
A[-1]
A[0]
1 0
0
0
A[-1]
P+P+-B
0101
01101
0101
-
Décaler A >>
Décaler P >>
(extension du signe)
Fin? NO
x
=
+
+
+
=
1
2
00110
1
P+P++B
B
0101
A
1101
11111011
0000101
111011
00000
11110001
11010
(5)
(-3)
[+(-5)]
[+5]
[+(-5)]
[+0]
(-15)
3
+
0101
-
1011
0010
1100
00000000
11011000
00010100
00011
0101
4
0000X
0101
Extension
du signe
11100010
11110001
Division - Nombres entiers
Division d’un nombre entier de n bits par un autre (A/B):
Décimal:
Binaire:
|
0909 Q
B 1100 | 1000100 A [0]
10001
[1]
- 09900
1010
[0]
10100
[1]
09900
200 R
|
0101 (5)
(12) 1100 | 1000100 (68)
10001
- 01100
1010
10100
- 01110
1000 (8)
Note: résultat -> quotient + reste!
Note: souvent le dividende A a une taille (nombre de bits) double par
rapport à la taille de B et de Q (1000100 -> 01000100)
Note: il ne faut pas oublier de détecter la division par 0
Division - Implémentation
|
0101
1100 |01000100
01000
10001
- 01100
1010
10100
01100
1000
Début
B est stockée dans la moitié
de poids fort du registre B
A est stockée dans le registre R
Q(2n)
≥0 R-B <0
RR-B
Décaler Q
(insérer 1)
Décaler Q
(insérer 0)
Décaler B (droite)
Fin? NO
2n
COMP
B(2n)
-[2n]
R (2n)
On peut simplifier la machine
comme pour la multiplication
Division - Implémentation
Début
≥0
R-B
0
<0
00000000
C
1
11000000
00000000
C
2
01100000
00000000
C
00110000
RR-B
Q << [0]
Q << [1]
-
Décaler B >>
Fin? NO
01000100
3
|
0101
1100 |01000100
01000
10001
- 01100
1010
10100
01100
1000
00000001
00011000
00010100
01000100
01000100
C
4
00000010
00001100
C
5
00000101
00000110
00010100
00001000
00010100
00001000
C
Division - Nombres signés
Approche « standard »: convertir les nombres négatifs en
positifs, diviser, convertir au négatif si nécessaire.
Pour déterminer le signe des résultats, la relation suivante doit
toujours être vraie:
Dividende = Quotient x Diviseur + Reste
Règle: dividende et reste doivent avoir le même signe!
+7 / +2: quotient = +3, reste = +1;
+7 / -2: quotient = -3, reste = +1;
-7 / +2: quotient = -3, reste = -1;
-7 / -2: quotient = +3, reste = -1;
Note: la valeur absolue reste la même!
Multiplication flottante
Nettement plus compliquée que la multiplication entière:
1.110x1010  9.200 x 10-5
1) Additionner les exposants: 10+(-5) = 5
Notation avec excès: 137 + 122 = 259 ??????
137 + 122 - 127 = 132 = 5 + 127
2) Multiplier les mantisses: 1.110 x 9.200 = 10.212000
3) Normaliser:
10.212000 x 105 = 1.0212000 x 106
4) Arrondir:
1.0212000 x 106 = 1.021 x 106
5) Trouver le signe:
+1.021 x 106
Multiplication flottante - Algorithme
Début
Additionner les exposants
Multiplier les mantisses
Normaliser le produit
NON
Arrondir
NON
OUI
(Sous-)Dépassement?
Exception
Normalisé?
Ajuster le signe du produit
OUI