1
Additionneurs
2
Rappel sur l'écriture des entiers en base 2
• Entiers positifs
• Entiers relatifs (complément à 2)
12,0,1,0,21
0
ni
in
ii AaaA
12,2,1,0,22 112
0
11
nn
ii
n
ii
nn BbbbB
3
Ci+1
Ai Bi
Ci
Si
Additionneur "Full Adder" (FA)
Ci+1 = AiBi + AiCi + BiCi= majorité(Ai,Bi,Ci)
Ci+1 = AiBi + Ci ( Ai Bi)
Si = Ai Bi Ci
000 0 0001 0 1010 0 1011 1 0100 0 1101 1 0110 1 0111 1 1
AiBiCi Ci+1 Si
La somme pondérée de ce qui entre est égale à la somme pondérée de ce qui sort :
Ai Bi Ci = Si + 2 * Ci+1
4
Ci+1 = 1 si retenue
Ci+1 = AiBi + AiCi + BiCi
Co=0
A0B0A1B1A2B2A3B3
C0C1C2C3C4
S0S1S2S3
Ci+1 = AiBi + Ci ( Ai Bi)
Si = Ai Bi Ci
I- Additionneur à propagation de retenue
S = A + B
A=A3 A2 A1A0 B=B3 B2 B1 B0
S=R S3 S2 S1S0
• La retenue se propage à travers tous les étages
• Délai = O(n)
5
II- Additionneur à sélection de retenue
(carry select adder CSA)
Idée : on sélectionne la retenue sortante à l'aide de la retenue entrante
La retenue entrante ne se propage pas à travers les FA on dispose de temps pour la calculer à mettre en poids fort (là où la retenue est en retard)
6
Cellule de CSA
Ci+1 = AiBi + Ci ( Ai Bi)
Si = Ai Bi Ci
7
Carry select adder CSA : Délai n1/2
01
1
2
11....5432
1
in
nnn
n 22
22
2
19822 2
0
t2t2t3t2t3t4t2t3t4t5
t3t4t5t6
t1t1t1 t1t2 t1
8
Première cellule d'un bloc CSA
• x
Ci+1 = AiBi + Ci ( Ai Bi)
Retenue1 = AiBi + 0 ( Ai Bi) = AiBi
Retenue2 = AiBi + 1 ( Ai Bi) = Ai+Bi
01
9
III Additionneur à retenue bondissante
• Idée : Si Ai=Bi=0, Ci+1=0 : pas de retenue quelque soit Ci
Si Ai=Bi=1, Ci+1=1 : il y a forcément une retenue, quelque soit Ci
Si Ai≠Bi, , la retenue sortante de l’étage i est égale à la retenue entrante
• Par blocs de p bits :– De même, la retenue sortante de l’étage i est égale à la
retenue entrante si et seulement si les Apbits sont les inverses des Bpbits
01101+ 10010+ Cin-------------Cin Somme
– Dans les autres cas, la retenue sortante peut être calculée indépendamment de la retenue entrante
10
Carry Skip ADDER
Ai,Bi, i=23,…,16 Ai,Bi, i=15,…,8 Ai,Bi, i=7,…,0
& calcule : (A0 B0).(A1 B1)…. (A7 B7)
Cn+
&+
&+
&
C0P7P15P23
Temps de calcul : plus long temps de propagation d’une retenue :une retenue se propage depuis le rang i où elle est générée (et pour lequel Gi=1) jusqu’au rang où la retenue suivante est générée
Un bloc est constitué d’un additionneur à propagation de retenueet d’un « circuit » détectant si pour chaque bit i du bloc on a Ai≠Bi,
11
Carry Skip ADDER
Remarques
• les signaux ne servent pas pour calculer la retenue (que la somme)
• Les signaux peuvent être calculés en parallèle• Les signaux peuvent être calculés en parallèle
Cn+
&
+
&
+
&
C0P7P15P23
12
Carry Skip ADDER
• Temps de calcul – pire cas : le retenue est générée au premier bloc, «
saute » les blocs suivants et est générée au dernier bloc
+&
+&
+&
+&
+&
Groupe 3 Groupe 2 Groupe 1
13
Carry Skip ADDER : taille des blocs
• Taille optimale des blocs (hyp : taille constante = k) ?m blocs de taille k : n = m * k ; m ? ; k ?
temps de traversée d’un bloc de k additionneurs : t1*ktemps de propagation : t2
Temps total (pire cas) : 2*t1*k + (m-2)*t2 = 2* t1 * n/m + (m-2) * t2
soit f(x) : 2*t1*n/x + (x-2) * t2minimum pour x0 = (2*n*t1/t2)1/2
f convexe sur R+ => m optimal : 2 valeurs entières qui encadrent x0
Temps total = O(n1/2)
exemple : additionneur de 60 bits, t1=t2 => x0=1201/2=10,95 m = 10 ou m =12 10 blocs de 6 bits ou 12 blocs de 5 bits
14
Carry Skip ADDER : taille des blocs
• Hypothèse: Groupes de même taille k , m=n/k groupes , k et n/k entiers
• k sélectionné pour minimiser le temps de la plus longue chaîne de propagation
• Notations:– tr - temps de propagation de la retenue sur un seul bit– ts(k) – Temps pour sauter un groupe taille k (la plupart du temps
- indépendant de k)– tb – délai du "OU" entre 2 groupes – Ttotal – temps total de propagation de la retenue – lorsque la
retenue est générée à l'étage 0 et se propage jusqu'à l'étage n-1
• La retenue se propage dans les étages 1,2, … ,k-1 du groupe 1, saute les groupes 2,3, … , (n/k-1), et se propage dans le groupe n/k
15
Carry Skip ADDER : taille des blocs
• Ttotal=(k-1)tr+tb+(n/k-2)(ts+tb)+(k-1)tr• Exemple - implémentation 2 niveaux
– tr = ts+tb=2G
– Ttotal=(4k+2n/k-7) G
• En dérivant Ttotal par rapport à k et en égalisant à 0 -
• kopt = n/2
• Taille des groupes et temps de propagation de la retenue proportionnel à n - idem carry-select adder
• Exemple : n=32, 8 groupes de taille kopt = 4 est la meilleure solution
• Topt=25G au lieu 62G pour un additionneur à propagation de retenue
16
Accélération
• Taille du premier et dernier groupe plus petite que la taille fixée k – le temps de propagation de la retenue dans ces groupes réduit
• Taille des groupes centraux augmentée – puisque le temps de "saut" est généralement indépendant de la taille du groupe
• Autre approche : ajouter un second niveau pour permettre le saut de deux ou plusieurs groupes en une étape (plus de 2 niveaux possible)
• Algorithmes existant pour déterminer les taille de groupes optimales pour différentes technologies et implantations (càd différentes valeurs du ratio (ts+tb)/tr)
17
Groupes de taille variable
• A l'inverse du cas des groupes constants – on ne peut se restreindre à l'analyse du pire cas de la propagation de la retenue
• Peut mener à la conclusion triviale : le premier et le dernier groupe composé d'un seul étage (1 bit) – les n-2 étages restants constituant un seul groupe central
• La retenue générée au début du groupe central peut se propager à travers les autre n-3 étages – et par là devenant le pire cas
• On doit donc considérer toutes les chaînes de retenue démarrant à n'importe quelle position arbitraire de bit a (avec
xa=ya) et s'arrêtant à b (xb=yb), position à laquelle une
nouvelle chaîne de retenue (indépendante de la précédente) commence. (X et Y opérandes)
18
Optimiser les taille de groupe
• k1, k2, … , kL – tailles des L groupes – avec • Cas général : Chaîne commençant dans le groupe u, finissant
dans le groupe v, sautant les groupes u+1, u+2, … ,v-1 • Pire cas - retenue générée à la première position dans u et
finissant dans la dernière position dans v • Le temps de propagation de la retenue est :
nkL
ii
1
LvuvuTcarryMinimiser
1),(max
1
1
).1())(().1(),(v
ulrvblsbru tktktttkvuTcarry
• Nombre de groupes L et tailles k1, k2, …, kL sélectionnées de telle façon que la plus longue chaîne de propagation de la retenue soit minimale • Solutions algorithmiques développées - programmation dynamique
19
Optimisation - Exemple
• additionneur 32-bit avec un seul niveau de saut• ts+tb=tr• Organisation optimale - L=10 groupes de taille k1,k2,…,k10
= 1,2,3,4,5,6,5,3,2,1• Résultat Tcarry 9 tr
• Si tr=2 G - Tcarry 18 G au lieu 25 G pour des groupes de taille égale
• Exercice: Montrer que toute paire de position de bits dans deux groupes quelconques u et v ( 1 u v 10 ) satisfait Tcarry(u,v) 9 tr
20
IV- Additionneur à retenue anticipée (Carry Look-Ahead : CLA)
• L'inconvénient des structures précédentes est le temps nécessaire à la réalisation de l'addition. Ce temps est en effet conditionné par la propagation de la retenue à travers tous les additionneurs élémentaires.
• Dans un additionneur à retenue anticipée on évalue en
même temps la retenue de chaque étage. Pour cela on détermine pour chaque étage les quantités Pi et Gi suivantes:– pi = ai bi (propagation d'une retenue)– gi = ai.bi (génération d'une retenue)
21
pi= ai bi (propagation d'une retenue)
gi = ai.bi (génération d'une retenue)
La retenue entrante à l'ordre i vaut 1 si :- soit l'étage i-1 a généré la retenue (gi-1 = 1)- soit l'étage i-1 a propagé la retenue générée à l'étage i-2 (p i-1=1 et gi-2=1)- soit les étages i-1 et i-2 ont propagé la retenue générée à l'étage i-3 (pi-1=pi-2=1 et gi-3=1)..........- soit tous les étages inférieurs ont propagé la retenue entrante dans l'additionneur (pi-1=pi-2=...=p0=c0=1).
ci = gi-1 + pi-1.gi-2 + pi-1.pi-2.gi-3 +................+ pi-1.pi-2.pi-3....p0.c0
c1 = g0 + p0.c0
c2 = g1 + p1.g0 + p1.p0.c0
c3 = g2 + p2.g1 + p2.p1.g0 + p2.p1.p0.c0
c4 = g3 + p3.g2 + p3.p2.g1 + p3.p2.p1.g0 + p3.p2.p1.p0.c0
Additionneur à retenue anticipée : CLA
22
Additionneur à retenue anticipée
pi= ai bi (propagation d'une retenue)
gi = ai.bi (génération d'une retenue)
Si = ai bi ci = pi ci
ci = gi-1 + pi-1.gi-2 + pi-1.pi-2.gi-3 +................+ pi-1.pi-2.pi-3....p0.c0
23
Additionneur à retenue anticipée
c0
g0p0g1p1g2p2g3p3
c4
s0s1s2s3
c3 c2 c1
g.p. g.p. g.p. g.p.
C.L.U.
a0b0a1b1a2b2a3b3
CLU : Carry Look-ahead Unit
p0p1p2p3
Si = pi ci
24
Bloc g.p.
pi= ai bi (propagation d'une retenue)
gi = ai.bi (génération d'une retenue)
g.p.
ai bi
pi gi
25
c4 c3 c2 c1
c0
p3 g3 p2 g2 p1 g1 p0 g0
Bloc CLU
Délai : 2 portes
ci = gi-1 + pi-1.gi-2 + pi-1.pi-2.gi-3 +................+ pi-1.pi-2.pi-3....p0.c0
26
C.L. Adder (n>4)
En pratique : n = 4
Pour n >4 :Arbre de C.L.A multi-niveau (au détriment de la vitesse)
c0c4
a0b0a1b1a2b2a3b3
c8
a4b4a5b5a6b6a7b7
c12
a8b8a9b9a10b10a11b11
27
V- Génération et propagation de groupe
Soient gi , pi , Pi,j Gi,j définis de la façon suivante :
Gi,i = gi = ai . bi : génération au rang i
Pi,i = pi = ai bi : propagation au rang i
Gi,k = Gi,j + Pi,j .Gj-1,k : génération du rang k au rang i (n>i≥j≥k≥0)
Pi,k = Pi,j .Pj-1,k : propagation du rang k au rang i
ci+1 = Gi,0 + Pi,0 . c0 : retenue au rang i+1 que l'on cherche à obtenir
Si = ai bi ci = pi ci = pi (Gi-1,0 + Pi-1,0 . c0); S0 =p0 c0
Si = ai bi ci = pi ci = pi Gi-1,0 ; S0 =p0 si c0=0
28
Cellule de Brent et Krung
Propriétés :– La cellule est associative => nombreux assemblages
possibles– Règle d’assemblage : toute sortie de rang i dépend des
entrées des rangs 0 à i – La cellule est non commutative
Gi,k = Gi,j + Pi,j .Gj-1,k
Pi,k = Pi,j .Pj-1,k
Pi,j Gi,j
Pj-1,k
Gj-1,k
Pi,k Gi,kPi,k
Pi,j Pj-1,k
Gi,k
Gi,j Pi,j Gj-1,k
Gi,i = gi
Pi,i = pi
n>i>j>k>1
29
Calcul arborescent
Le calcul des autres retenues peut-être fait :- 1 à coût minimum,- 2 rapide à fanout variable, - 3 rapide à fanout fixe
3,25,47,69,811,1013,1215,14
7,411,815,12
15,8
Si = pi Gi-1,0
15 14 13 12 11 10 9 8 7 6 5 4 3 2 1 0
30
Additionneur Brent & Kung en temps log2(n)+2
Gi
calcul pi et gi
si = pi Gi-1,0C16
31
Additionneur de Brent & Kung
temps
32
Règles de construction
Il y a une seule règle de construction des arbres imbriqués de cellules "BK" : Toute retenue ci de rang i est reliée à toutes les entrées de rang j < i par un arbre binaire planaire de cellules "BK".
Cela permet d'entrelacer les arbres des n sorties de très nombreuses façons en fonction du nombre de bits et du délai de l'additionneur.
Ce délai va de (n-1) à log2(n), bornes comprises.
33
Additionneur de Brent & Kung modifié
Modification de Fishburn (1990) : une cellule de plus mais réduction de 6 à 5
G14,0 = G14,14 + P14,14 .G13,0
G14,0= G14,12+ P14,12 .G11,0
G14,12= G14,0+ P14,0 .G13,12
34
Additionneur de Sklansky en temps log2(n)
Délai : log2(n) contre log2(n)+2Nombre de celules : 32 contre 27
35
Additionneur en temps (n1/2)
36
Additionneur en temps (n1/3)
37
Exercice
38
Additionneur de Ling (1981)
ki = le retenue a été tuée au rang i = ai' . bi
' Remarque : gi = k'i
gi
Calcul de la 6ième retenue
S6 = p6 G5,0
G5,0 = G5,3 + P5,3 G2,0
G5,3 = g5 + k'5 g4 + k'5k'4 g3
G2,0 = g2 + k'2 g1 + k'2k'1 g0
P5,3 = k'5k'4 k'3
Le délai de S6 est déterminé par G5,0 dont tous les termes contiennent k'5 sauf le premier .
Or g5 = k'5 g5. On met k'5 en facteur : S6 = p6 k'5 H5,0 (Hi,0 pseudo-retenue au rang i)
H5,0 = H5,3 + Q5,3 H2,0
H5,3 = g5 + g4 + k'4 g3
H2,0 = g2 + g1 + k'1 g0
Q5,3 = k'4 k'3 k'2
39
Additionneur de Ling
Pour S6 on précalcule p6 et p6 k'5
G5,3 = g5 + k'5 g4 + k'5k'4 g3 = a5b5 + (a5+b5)a4b4 + (a5+b5) (a4+b4)a3b3
H5,3 = g5 + g4 + k'4 g3 = a5b5 + a4b4 + (a4+b4)a3b3
H5,3 est plus rapide à calculer que G5,3
40
• But : éviter la propagation de la retenue• Astuce : coder les chiffres sur 2 bits• Le résultat est la somme de l'addition et de la retenue de
l'étage précédent
• codage :0 : 00, 1 : 01 ou 10, 2 : 11
Additionneurs Parallèles
2,1,0,,,,, 2221
0
1
0
1
0
sbasba iii
in
ii
in
ii
in
ii
SBA
41
• Cellule CS : somme pondérée des sorties = somme pondérée des entrées
a + b + c + d + e = 2*h + 2*g + f
Cellule CS (Carry-Save)
• La sortie "h" ne dépend pas de l'entrée "e".• h : retenue pour le bit suivant• g : partie du résultat pour le bit suivant• Chaque chiffre est maintenant représenté sur 2 bits • la valeur du chiffre est la somme de ces deux bits. Les valeurs possibles des
chiffres "CS" sont donc '0', '1' et '2' .
CS
a b c d e
h g f
a+b+c+d h g f0 0 0 e1 0 e e'
21
ou 00
ou 1e
3 1 e e'4 1 1 e
42
Additionneur parallèle CS
CS CS CS
s0
a2 b2 a1 b1 a0 b0
s1s2
g g gf f f
0
43
44
Table de vérité
h = majorité (a,b,c)
f = (somme (a,b,c,d,) e ) = somme (a,b,c,d,e)
g = majorité (somme(a,b,c),d,e)
a + b + c + d + e = 2*h + 2*g + f
45
Implantation : additionneur parallèle CS
FA
FA
a b c d
h
g f
g
g
e
h = majorité (a,b,c)
f = somme (a,b,c,d,e)
g = majorité (somme(a,b,c),d,e)
46
Additionneur parallèleai {0,1,2} Codage : ai:{ai1,ai2} / ai1+a12 = ai0 : 001 : 01 ou 102 : 11
CS
47
Implantation Cellule CS (Carry-Save)
48
Variantes
49
Additionneurs de réels
50
Nombre réels
• Codage des réels : virgule flottante• flottant stocké sous la forme M * BE
– M : Mantisse ; B : Base ; E : Exposant
• exemple : 123 . 103 = 123 000• Représentation IEEE 754, base 2 (signe 1 bit, exposant
et mantisse sur 32 ou 64 bits pour simple et double précision)
• SM : signe de la mantisse : 1 bit• Eb : exposant biaisé : 8 ou 11 bits • M : Mantisse : 23 ou 52 bits
SM Eb M
51
Mantisse et exposant
• Signe : bit de poids fort (0 = + ; 1 = -)• Exposant
– placé avant la mantisse pour simplifier les comparaisons (pour ceci il ne doit pas être représenté en complément à deux : 2-1 > 2)
– sur 8 bits : 0..255 – sans signe mais biaisé de 127 (on enlève 127) :– Eb = 0 ⇒ E = 0 – 127 = -127– Eb = 255 ⇒ E = 255 – 127 = 128– les exposants 127 (erreur) et 0 (nb dénormalisé) sont interdits
• Remarque : E>0 si et seulement si le bit de poids fort de Eb =1
• Mantisse– normalisée : bit de poids fort n’est pas 0 et un seul chiffre avant la
virgule
• ex : 3,2510 =11,01 = 1,101 * 21
52
Virgule Flottante
• Mantisse : Comme le bit de poids fort de la mantisse est nécessairement 1, on ne l’indique pas (gaspillage de place). Il est implicite– partie fractionnaire = f1f2 …fn ⇒ m = 1,f1f2…fn– nombre x = (-1)SM * 1,M * 2Eb-127
• Exemple
– x = (-2,5)10 = (-1,01*21)2
– SM = 1 ; – E= 1 => Eb= 128 = 1000 0000 ; – m=1,01 => M = 010…….0
1 1000 0000 010……0
53
Exemple : 452,5 + 117,5
A=1.11000100100000000000000*28
B=1.11010110000000000000000*26452,5=117,5=
A=1.11000100100000000000000*28
B=0.0111010110000000000000000*28452,5=117,5=
A+B = 10.0011101000000000000000000*28
= 1.0001110100000000000000000*29
54
Addition virgule flottante
• Les réels étant codés en "signe/valeur absolue", un seul opérateur pour addition et soustraction (Cmpà1 +1 si signes dif.)
• Exposant du résultat : exposant du + grand (voir la suite)
• Déroulement de l'addition– alignement des mantisses si les exposants sont dif.– addition ou soustraction des mantisses alignées– renormalisation de la mantisse de la somme S (si elle n'est
pas normalisée) => modif de l'exposant– arrondi de la mantisse
55
Exemple : 452,5+117,5
A=1.11000100100000000000000*28
B=1.11010110000000000000000*26
Alignement des mantissesB= 0.01110101100000000000000|00*28
Addition des mantisses alignées A=1.110001001000000000000000000*28
+B=0.011101011000000000000000000*28
S=10.001110100000000000000000000*28
Normalisation de la mantisseS'=1.000111010000000000000000000*29
Arrondi de la mantisseS'=1.00011101000000000000000*29
452,5=117,5=
56
Alignement des mantisses
• Par décalage de p bits
• La valeur p du décalage est donnée par la différence des exposants. Dans l'exemple 8-6 =2 . Décalage de 2 bits.
• La valeur max de décalage est 23 , la différence est codée sur 5 bits
57
Architecture : huit blocsBloc 1: entrent les deux exposants, sort plus grand exposant (8 bits), sort la
valeur absolue de la différence des exposants (5 bits), sort le bit implicite du plus petit opérande et le bit implicite du plus grand opérande.
Bloc 2: entrent les deux mantisses, sort à gauche la mantisse du plus petit opérande (23 bits), sort à droite la mantisse du plus grand opérande (23 bits). Commande le mux du signe résultat (signe du plus grand).
Décaleur 1: décale vers la droite la mantisse du plus petit, conserve un "bit de garde" et un "bit d'arrondi" et ajoute un "bit collant"; total 27 bits.
Complémenteur: fait sur commande le complément logique en vue d'une soustraction.
Additionneur 1: additionne les deux mantisses alignées et la retenue, sort un résultat arrondi et une retenue, en tout 28 bits (dont 2 avant la virgule et 5 servant à l'arrondi dont 2 perdus).
Compteur de zéros en tête: la sortie ZLC compte le nombre de '0' en poids forts ou vaut 1 si le comptage est inhibé.
Décaleur 2: décale vers la gauche de ( ZLC – 2 ) positions (de 2 positions à droite jusqu'à 23 positions à gauche). Sort la mantisse du résultat, le bit sortant poids fort est perdu (bit '1' implicite si normalisé).
Additionneur 2: soustrait ( ZLC – 1 ) du plus grand exposant. Sort l'exposant du résultat.
58
Architecture
voir : http://tima-cmp.imag.fr/~guyot/Cours/Oparithm/francais/Flottan.htm
452,5+117,5
59
Multiplieurs
60
Multiplication binaire
1 1 0 0 Multiplicande 1 1 0 1 Multiplieur --------- 1 1 0 0 Produit partiel 0 0 0 0 Produit partiel 1 1 0 0 Produit partiel
1 1 0 0 Produit partiel ------------------- 1 0 0 1 1 1 0 0
1 2 * 1 3 -------- 3 6
1 2 -------- 1 5 6
61
A3 B0 A2B0 A1B0 A0B0
A3 B1 A2B1 A1B1 A0B1
A3 B2 A2B2 A1B2 A0B2
A3 B3 A2B3 A1B3 A0B3
PP1PP2PP3PP4
PP1 + PP2 = R1 => R1 + PP3 = R2 => R2 + PP4 = P
+
Ri Ai-1Bj
Ri+1
Multiplieur
P = A * B
A=A3 A2 A1A0 B=B3 B2 B1 B0
P=P7P6P5P4P3 P2 P1P0 B3 B2 B1 B0
A3 A2 A1 A0
*
P7 P6 P5 P4 P3 P2 P1 P0
62
A3 B0 A2B0 A1B0 A0B0
A3 B1 A2B1 A1B1 A0B1
A3 B2 A2B2 A1B2 A0B2
A3 B3 A2B3 A1B3 A0B3
P7 P6 P5 P4 P3 P2 P1 P0
+ + + +
+ + + +
+ + + +
B0
B1
B2
B3
A0A1A2A3
A0A1A2A3
A0A1A2A3
A0A1A2A3
0
0
0
0
Multiplieur
63
Multiplieur naïf (5 x 6)
25 Adders, chemin critique 13 adders
64
Multiplieur amélioré
24 adders, chemin critique 9 adders
Tous les chiffres d'un même colonne ont même poids.En jouant sur :
- l'associativité et la commutativité de l'addition- sur le fait que l'on ajoute des 0 sur la première couche diagonale
on peut réduire le chemin critique
65
A4B0 A3 B0 A2B0 A1B0 A0B0
A4B1 A3B1 A2B1 A1B1 A0B1
A4B2 A3B2 A2B2 A1B2 A0B2
A4B3 A3B3 A2B3 A1B3 A0B3
Multiplieur de Braun
B5 B4 B3 B2 B1 B0
A4 A3 A2 A1 A0
*
P9 P8 P7 P6 P5 P4 P3 P2 P1 P0
A4B4 A3B4 A2B4 A1B4 A0B4
A4B5 A3B5 A2B5 A1B5 A0B5
Avec P0= A0B0, P1=A1B0+A0B1, P2 = A2B0+A1B1+A0B2, etc…
66
Multiplieur de Braun
24 adders, chemin critique 9 adders
67
Multiplication Signée (complément à 2)
68
Multiplieur séquentiel 1
(A) 1110 (B) 1011 -------------R2R1 0000 0000 Initialisation de R1 et R2+A*20 1110 b0=1 => on ajoute A*20
-------------R2R1 0000 1110 Décalage de B => B=(0101)+A*21 1 110 b0=1 => on ajoute A*21
-------------R2R1 0010 1010 Décalage de B => B=(0010)+0*22 b0=0 => on ajoute 0*22
-------------R2R1 0010 1010 Décalage de B => B=(0001)+A*23 111 0 b0=1 => on ajoute A*23
-------------R2R1 1001 1010 Fin
Avec addition de A sur le ième bit
69
Multiplieur séquentiel 2
(A) 1110 (B) 1011 ---------------R3R2R1 0 0000 0000 Initialisation de R3 R2 R1+A 1110 b0=1 => (R2 + A -> R3R2) ---------------R3R2R1 0 1110 0000 Décalage de R3R2R1R3R2R1 0 0111 0000 Décalage de B => B=(0101) +A 1110 b0=1 => (R2 + A -> R3R2) ---------------R3R2R1 1 0101 0000 Décalage de R3R2R1R3R2R1 0 1010 1000 Décalage de B => B=(0010) +0 0000 b0=0 => (R2 + 0 -> R3R2) ---------------R3R2R1 0 1010 1000 Décalage de R3R2R1R3R2R1 0 0101 0100 Décalage de B => B=(0001) +A 1110 b0=1 => (R2 + A -> R3R2) ---------------R3R2R1 1 0011 0100 Décalage de R3R2R1R3R2R1 0 1001 1010 Fin
Avec addition de A sur les poids forts et décalage
A la ième itération : n-i bits à 0 et n-i bits utiles dans B
70
Multiplieur séquentiel 3 (A) 1110
---------------R3 R2 R1 0 0000 1011 Initialisation de R3R2R1 (B->R1)+A 1110 b0(R1)=1 => (R2 + A -> R3R2) ---------------R3 R2 R1 0 1110 1011 Décalage de R3R2R1R3 R2 R1 0 0111 0101 b0(R1)=1 => (R2 + A -> R3R2) +A 1110 ---------------R3 R2 R1 1 0101 0101 Décalage de R3R2R1R3 R2 R1 0 1010 1010 b0(R1)=0 => (R2 + 0 -> R3R2) +0 0000 ---------------R3 R2 R1 0 1010 1010 Décalage de R3R2R1R3 R2 R1 0 0101 0101 b0(R1)=1 => (R2 + A -> R3R2) +A 1110 ---------------R3 R2 R1 1 0011 0101 Décalage de R3R2R1R3 R2 R1 0 1001 1010 Fin
71
Multiplieur séquentiel 4
architecture SHIFT_MULT of MULT isbegin process variable A,B,M : BIT_VECTOR; variable COUNT : INTEGER; begin wait until (START=1); B:=B_PORT; COUNT:=0; A:=A_PORT; DONE<='0'; M:=b"00000"; while (COUNT<4) loop
M:=M+A; endif; B:=SHR(B,M(0)); M:=SHR(M,'0'); COUNT:=COUNT+1; endloop; M_OUT<=M&B; DONE<='1' endprocess;end SHIFT_MULT;
entity MULT isPORT( A_PORT,B_PORT : in bit_vector(3 downto 0); M_OUT : out bit_vector(7 downto 0); CLK : in CLOCK. START : in BIT; DONE : out BIT; );end MULT;
A_PORT B_PORT
START
CLK
M_OUT DONE if (B(0) = ‘1’)
72
Description structurelle
Mux1Mux2Mux3Mux4Load A_RegLoad B_RegClear Count_RegLoad Count_RegClear MultLoad MultAdderSchift 1Schift 2DONENext State
1 01 0
0 10
1 111
11
1 11 1
11
0 11 0 2 0 3 3 1
Control Unit
S0&
STA
RT
=1
S0&
~(S
TA
RT
=1
) S1&
CO
UN
T<
4
S1&
~(C
OU
NT
<4)
S2&
B(0
)=1
S2&
~(B
( 0)=
1)
S3 Count_Reg
Adder
Mux1
M_Reg
B_Reg A_reg
State Reg
Mux2
Mux3 Mux4
Comp
Shift2Shift1
Concat
CLK DONE M_OUT
B_PORT A_PORT
00010
0100
B_reg(0)
Compar.LT
M(0)
73
Synthèse contrôle
S0
S1
S2
S3
Start = 0
Start = 1 /
Count = 4 /
Count < 4
B(0) = 1 /
A:=A_PORT;B:=B_PORT;COUNT:=0;DONE:='0';M:="00000";
M_OUT:=M@B;DONE:='1';
M:=M+A
B(0) 1 B:=SHR(B,M(0));M:=SHR(M,'0');COUNT:=COUNT+1;
Synthèse contrôle
CONDITION VALEUR ACTIONSEtat Présent
S0 START=1
T
F
A:=A_PORT;B:=B_PORT;COUNT:=0;DONE:='0';
M:="00000";
S1 COUNT<4T
F M_OUT:=M@B;DONE:='1';
S1
S0
S2
S0
S2 B(0)=1
T
F
M:=M+A S3
S3
S3B:=SHR(B,M(0));M:=SHR(M,'0');COUNT:=COUNT+1;
S1
Etat Futur
75
Synthèse contrôleur
Mux1Mux2Mux3Mux4Load A_RegLoad B_RegClear Count_RegLoad Count_RegClear MultLoad MultAdderSchift 1Schift 2DONENext State
1 01 0
0 10
1 111
11
1 11 1
11
0 11 0 2 0 3 3 1
S0&
ST
AR
T=
1
S0&
~(S
TA
RT
=1)
S1&
CO
UN
T<
4
S1&
~(C
OU
NT
<4 )
S2&
B(0
)=1
S2&
~(B
(0)=
1 )
S3
State Reg
DONE
Start
B_reg(0)Compar.LT
Chemin de données
76
Multiplieur de Booth : Principe
L'algorithme de Booth est basé sur 2 principes :- une suite de 0's dans B ne demande ni addition
ni soustraction (juste un décalage)- une suite de 1's dans B est associée avec une
combinaison de soustractions (là où la suite commence) et une addition (là où la suite finit).
Justification : …..0111110….. = .….100000
- 1Donc :au passage 01 on rajoute Aau passage 10 on enlève A
77
Multiplieur de Booth : Implantation
Multiplication de 2 nombres A et B sur N bits signés en C2
• Cpt est un compteur de séquence (N)• BC est un registre de 2 bits (fenêtre)• B et A sont des registres de N et N+1 bits.
– Initialement B est chargé dans le registre B – A est chargé dans A et son signe est recopié dans le bit de
poids fort (AN et AN-1 ont même valeur)
• Les registres B et BC concaténés sont notés B:BC, donc B:BC a N+2 bits.
• P a 2N bits de long et contiendra le produit final. Les N+1 bits de poids fort sont appelés PH et les N-1 de poids faibles PL.
78
Algorithme de Booth
• 1. Initialisation: – Le multiplicande est chargé dans A (et étendu à N+1 bits), le
multiplieur dans B.– La valeur N est chargée dans Cpt.– P et BC sont initialisés à zéro
• 2. Décalage arithmétique à droite: ashift (recopie du bit de poids fort) préserve le signe d'un nombre en complément à 2 (c'est une division par 2). – Faire un ashift sur P– Faire ashift sur B:BC
• 3. Addition, Soustraction, ou Nop: – si BC = 01b alors Additionner A à PH, sinon– si BC = 10b alors Soustraire A à PH. (pour soustraire, faire le
complément à 2 et additionner)– sinon (BC = 00 ou 11) ne rien faire Nop
• 4. Décrémenter Cpt, si Cpt ≠ 0, retourner en 2 sinon fin
79
Exemple : N=5, P= (-5) * (+2)
Etapes B BC PH PL Cpt1 11011 00 000000 0000 5
2 11101 10 000000 0000 soustraction111110+
------3,4 111110 0000 4
2,3,4 11110 11 111111 0000 3 nop
2 11111 01 111111 1000 addition000010+------
3,4 000001 1000 2
2 11111 10 000000 1100 soustraction111110+------
3,4 111110 1100 1 nop
2,3,4 11111 11 111111 0110 0
Résultat : 1111110110b est le complément à 2 de 00000010102 = 10d càd -10
B= -5 (11011b) A= +2 (00010b). Le complément à 2 de A est 111110b
80
Améliorations
• Alors qu'avec cette version , on utilise un additionneur N+1 bits, on peut n'utiliser qu'un additionneur N bits (mais il faut gérer le dépassement de capacité en complément à 2)
• Chaque itération comporte une opération de décalage, donc les étapes 2 et 3 peuvent être combinées pour gagner du temps.
• Finalement, on peut éliminer le registre B, en se servant de PH pour mémoriser le multiplicande.
81
Multiplieur virgule flottante
Exemple : P= A*B= 452,5*117,5
Signe du produit : "et" des bits de signe
Exposant du produit : Somme des exposantsEb(P)= E(P)+127= Eb(A)-127+Eb(B)-127+127 = Eb(A)+Eb(B)-127
Mantisse du produit : Produit des mantisses et recadrage => modification de l'exposant
82
Division
83
1 0 1 1- 1 0 0 1--------------- 0 0 1 0 0- 1 0 0 1--------------- 0 1 0 0 0 - 1 0 0 1 ---------------- 1 0 0 0 0- 1 0 0 1----------------- 0 1 1 1
1 ,0 0 1
1 0 0 1
1
0
0
1
Soustraction 5 bits
Exemple : 11 / 9
Division Binaire
1 1 9
2 0 1 , 2 2 ...
2 0 2
84
- 1 0 0 1Q R R R R
R R R R
1 0 1 1- 0 1 0 0 10
1 0- 0 1 0 0 10
1 0 1- 0 1 0 0 10
1 0 1 1- 0 1 0 0 11
0 0 1 0 0- 0 1 0 0 10
0 1 0 0 0- 0 1 0 0 10
1 0 0 0 0- 0 1 0 0 11
0 1 1 1 0- 0 1 0 0 11
,
Si R>D alors Q=1 et R-D sinon Q=0 et R
Diviseur
S = A / D
A=A3 A2 A1A0 D=D3 D2 D1 D0
S=S7S6S5S4,S3 S2 S1S0
85
R
+
01
+ -
R D
Si alors
Ci+1 Ci
- Si
D-
R
RSi
CiCi+1+
Diviseur
Do+ - + - + -
D1D2+ -
D30+ -
0
Do+ - + - + -
D1D2+ -
D30+ -
0
Do+ - + - + -
D1D2+ -
D30+ -
0
Do+ - + - + -
D1D2+ -
D30+ -
0
Do+ - + - + -
D1D2+ -
D30+ -
0
Do+ - + - + -
D1D2+ -
D30+ -
0
Do+ - + - + -
D1D2+ -
D30+ -
0
A3
A2
A1
A0
0
0
0
0 0 0 0
Q3
Q2
Q1
Q0
Q-1
Q-2
Q-3
,
86
Do+ - + - + -
D1D2+ -
D30+ -
0
Do+ - + - + -
D1D2+ -
D30+ -
0
Do+ - + - + -
D1D2+ -
D30+ -
0
Do+ - + - + -
D1D2+ -
D30+ -
0
Do+ - + - + -
D1D2+ -
D30+ -
0
Do+ - + - + -
D1D2+ -
D30+ -
0
Do+ - + - + -
D1D2+ -
D30+ -
0
A3
A2
A1
A0
0
0
0
0 0 0 0
Q3
Q2
Q1
Q0
Q-1
Q-2
Q-3
,
Diviseur
87
Fin
88
Additionneur Brent & Kung en temps log2(n)+2
Gi