Additionneurs
Rappel sur l'écriture des entiers en base 2
• Entiers positifs
• Entiers relatifs (complément à 2)
2
0,1 ,
0,2 1
, 2
1 0
i n n i
i
i a A
a A
0 , 1 , 2 , 2 1
, 2
2
2 1 10 1
1
n i i n ni
i n
n
b b B
b
B
Additionneur "Full Adder" (FA)
Ci+1
Ai Bi
Ci
Si
C
i+1= A
iB
i+ A
iC
i+ B
iC
i= majorité(A
i,B
i,C
i) C
i+1= A
iB
i+ C
i( A
i B
i)
S
i= A
i B
i C
i000 0 0 001 0 1 010 0 1 011 1 0 100 0 1 101 1 0 A
iB
iC
iC
i+1S
iLa somme pondérée de ce qui entre est égale à la somme pondérée de ce qui sort :
A
i+ B
i +C
i= S
i+ 2 * C
i+1I- Additionneur à propagation de retenue
4
C
i+1= 1 si retenue
Ci+1 = AiBi + AiCi + BiCi C
o=0
A
0B
0A
1B
1A
2B
2A
3B
3C
0C
1C
2C
3C
4S
0S
1S
2S
3Ci+1 = AiBi + Ci ( Ai
Bi) Si = Ai
Bi
Ci
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)
000 0 0 001 1 1 010 1 1 011 1 0 100 0 1 101 0 0 110 0 0 111 1 1
Ci+1 = 1 si retenue AiBiCi Ci+1 Si
Ci+1 = AiBi + AiCi+BiCi
Co=0
0 1 1 1
00 01 11 10 0
Ai BiCi
Ci+1
S i = Ai Bi Ci
A0B0 A1B1
A2B2 A3B3
C0 C1
C2 C3
C4
S0 S1
S2 S3
+ - + - + - + -
Soustracteur
S = A - B
A=A3 A2 A1A0 B=B3 B2 B1 B0
S=R S3 S2 S1S0
A1B1 A2B2
A3B3
C2 C3
C4
- - -
A0B0
C0=0 C1
-
S0 S1
S2 S3
si A>B alors C
4=0 si A<B alors C
4=1
+ - + - + - + -
Ci+1
Ai Bi
Ci
Si
Soustracteur
Ci+1 = AiBi + AiCi + BiCi Ci+1 = AiBi + Ci ( Ai Bi)
S i = Ai Bi Ci
Ci+1
Ai Bi
Ci Ai Bi
Ci+1 Ci
Ci+1 = AiBi + Ci ( Ai Bi) S i = Ai Bi Ci
Ci+1 = AiBi + Ci ( Ai Bi) S i = Ai Bi Ci
A
iB
iC
iC
i+1-
A
iB
iC
iC
i+1+
+ -
Soustracteur
A1B1 A2B2
A3B3
C2 C3
C4
- - -
A0B0
C0=0 C1
-
S0 S1
S2 S3
C2 C3
C4
+ + +
A1B1 A2B2
A3B3 A0B0
C0=0 C1
+
S0 S1
S2 S3
+ - + - + - + -
Soustracteur
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
Cellule de CSA
Ci+1 = AiBi + Ci ( Ai
Bi)
10Si = Ai
Bi
Ci
Carry select adder CSA : Délai n
1/201
12 1 1
....
5 4 3 2
1
i n
n n
n n 2
2 2 2 2
1 9 2 8
2 2
0
t2 t2
t3 t2
t3 t4
t2 t3
t4 t5
t3 t4
t5 t6
t1 t1
t1 t2 t1 t1
Première cellule d'un bloc CSA
• x
12
Ci+1 = AiBi + Ci ( Ai
Bi)
Retenue1 = AiBi + 0 ( Ai
Bi) = AiBi Retenue2 = AiBi + 1 ( Ai
Bi) = Ai+Bi
01
III Additionneur à retenue bondissante (Carry Skip Adder)
• 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
Carry Skip ADDER
14
Ai,Bi, i=23,…,16 Ai,Bi, i=15,…,8 Ai,Bi, i=7,…,0
&
calcule : (A0 B0).(A1 B1)…. (A7 B7)Interprétation : Propagation de la retenue entre 0 et 7 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 retenue et d’ un « circuit » détectant si pour chaque bit i du bloc on a Ai≠Bi,
C
n+
&
P23
+
&
P15
C
0+
&
P7
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
Carry Skip ADDER
C
0C
n+
&
P23
+
&
P15
+
&
P7
Carry Skip ADDER
16
+ &
+ &
+ &
+ &
• Temps de calcul
– pire cas : le retenue est générée au premier bloc, « saute » les blocs suivants et traverse le dernier bloc pour calculer la somme
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
temps de traversée d’ un bloc de k additionneurs 1 bit : t1*k
temps de propagation à l'aide des comparateurs: t2 ("mux") Temps total (pire cas) : 2*t1*k + (m-2)*t2 = 2* t1 * n/m +
(m-2) * t2
• Il suffit de déterminer où cette fonction est minimale.
Carry Skip ADDER : taille des blocs
Sous hypothèse 1 : le temps de propagation à travers les comparateurs est constant
soit f(x) : 2*t1*n/x + (x-2) * t2 minimum 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
18
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 "MUX" 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, … , m-1, et se propage dans legroupe m
Carry Skip ADDER : taille des blocs
• T
total=(k-1)t
r+t
b+(m-2)(t
s+t
b)+(k-1)t
r• Exemple - implémentation 2 niveaux
– tr = ts+tb = 2
G (
G = délai d'une porte) – Ttotal=(4k+2n
/k-7)
G• En dérivant T
total par rapport àk et en égalisant à 0 -
• k
opt= 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=25
Gau lieu 62
Gpour un additionneur à propagation de retenue
20
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 à peu près 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 existants pour déterminer les taille de groupes optimales pour différentes technologies et implantations (càd différentes valeurs du ratio (ts+tb)/tr)
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
x
a=y
a) ets'arrêtant à b (
x
b=y
b), position à laquelle une nouvelle chaîne de retenue (indépendante de la précédente) commence. (X et Y opérandes)22
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 : n k
L i
i
1
Tcarry u v Minimiser max ( , )
11
).
1 (
) )
( ( ).
1 (
) ,
(
vu l
r v
b l
s b
r
u
t t t k t k t
k v
u Tcarry
• 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
Optimisation - Exemple
• additionneur 32-bit avec un seul niveau de saut
• t
s+t
b=t
r• Organisation optimale - L=10 groupes de taille k
1,k
2,…,k
10= 1,2,3,4,5,6,5,3,2,1
• Résultat T
carry 9 t
r• Si t
r=2
G- T
carry 18
Gau lieu 25
Gpour 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
T
carry(u,v) 9 t
r24
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)
Additionneur à retenue anticipée : CLA
26
p
i= a
i b
i(propagation d'une retenue) g
i= a
i.b
i(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 (g
i-1= 1)
- soit l'étage i-1 a propagé la retenue générée à l'étage i-2 (p
i-1=1 et g
i-2=1) - soit les étages i-1 et i-2 ont propagé la retenue générée à l'étage i-3 (p
i-1=p
i-2=1 et g
i-3=1)
...
- soit tous les étages inférieurs ont propagé la retenue entrante dans l'additionneur (p
i-1=p
i-2=...=p
0=c
0=1).
c
i= g
i-1+ p
i-1.g
i-2+ p
i-1.p
i-2.g
i-3+...+ p
i-1.p
i-2.p
i-3....p
0.c
0c
1= g
0+ p
0.c
0c
2= g
1+ p
1.g
0+ p
1.p
0.c
0c
3= g
2+ p
2.g
1+ p
2.p
1.g
0+ p
2.p
1.p
0.c
0c
4= g
3+ p
3.g
2+ p
3.p
2.g
1+ p
3.p
2.p
1.g
0+ p
3.p
2.p
1.p
0.c
0Additionneur à retenue anticipée
p
i= a
i b
i(propagation d'une retenue) g
i= a
i.b
i(génération d'une retenue) S
i= a
i b
i c
i= p
i c
ic
i= g
i-1+ p
i-1.g
i-2+ p
i-1.p
i-2.g
i-3+...+ p
i-1.p
i-2.p
i-3....p
0.c
0Additionneur à retenue anticipée
28
c0 g0
p0 g1
p1 g2
p2 g3
p3 c4
s0 s1
s2 s3
c3 c2 c1
g.p. g.p. g.p. g.p.
C.L.U.
a0 b0 a1
b1 a2
b2 a3
b3
CLU : Carry Look-ahead Unit
p0 p1
p2 p3
S
i= p
i c
iBloc g.p.
pi= ai bi (propagation d'une retenue) gi = ai.bi (génération d'une retenue)
g.p.
a
ib
ip
ig
iBloc CLU
30
c4 c3 c2 c1
c0
p3 g3 p2 g2 p1 g1 p0 g0
Délai : 2 portes
c
i= g
i-1+ p
i-1.g
i-2+ p
i-1.p
i-2.g
i-3+...+ p
i-1.p
i-2.p
i-3....p
0.c
0C.L. Adder (n>4)
En pratique : n = 4 Pour n >4 :
Arbre de C.L.A multi-niveau (au détriment de la vitesse)
c4 c0
a0 b0 a1 b1 a2 b2 a3 b3
c8
a4 b4 a5 b5 a6 b6 a7 b7
c12
a8 b8 a9 b9 a10 b10 a11 b11
V- Génération et propagation de groupe
32
Soient g
i, p
i, P
i,j G
i,jdéfinis de la façon suivante :
G
i,i= g
i= a
i. b
i: génération au rang i P
i,i= p
i= a
i b
i: propagation au rang i
G
i,k= G
i,j+ P
i,j.G
j-1,k: génération du rang k au rang i (n>i≥j≥k≥0)
P
i,k= P
i,j.P
j-1,k: propagation du rang k au rang i
Gi,k : la retenue qui sort de l'étage i a été générée entre l'étage k et l'étage i Pi,k : le retenue entrant à l'étage k a été propagée jusqu'à la sortie de l'étage i
c
i+1= G
i,0+ P
i,0. c
0: retenue au rang i+1 que l'on cherche à obtenir
S
i= a
i b
i c
i= p
i c
i= p
i (G
i-1,0+ P
i-1,0. c
0)
et S
0=p
0 c
0Cellule 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
G
i,k= G
i,j+ P
i,j.G
j-1,kP
i,k= P
i,j.P
j-1,kP
i,jG
i,jP
j-1,kG
j-1,kP
i,kG
i,kP
i,kP
i,jP
j-1,kG
i,kG
i,jP
i,jG
j-1,kG
i,i= g
iP
i,i= p
in ≥ i ≥ j ≥ k ≥ 1
Calcul arborescent de la retenue de sortie
34
Le calcul des autres retenues peut-être fait : - 1 à coût minimum,
- 2 rapide à fanout variable, - 3 rapide à fanout fixe
3,2 5,4
7,6 9,8
11,10 13,12
15,14
7,4 11,8
15,12 15,8
S
i= p
i (G
i-1,0+ P
i-1,0. c
0)
15 14 13 12 11 10 9 8 7 6 5 4 3 2 1 0
c
i+1= G
i,0+ P
i,0. c
0Additionneur Brent & Kung
calcul pi et gi
S
i= p
i ( G
i-1,0+ P
i-1,0. c
0)
C16
S
i= p
i (G
i-1,0+ P
i-1,0. c
0)
c
i+1= G
i,0+ P
i,0. c
0Additionneur Brent & Kung
36
calcul pi et gi
S
i= p
i ( G
i-1,0+ P
i-1,0. c
0)
Additionneur Brent & Kung en temps log
2(n)+2
calcul pi et gi
S
i= p
i ( G
i-1,0+ P
i-1,0. c
0)
C16
Additionneur de Brent & Kung
38
temps
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) à log
2(n), bornes comprises.
Additionneur de Brent & Kung modifié
40
Modification de Fishburn (1990) : une cellule de plus mais réduction de 6 à 5
G
14,0= G
14,14+ P
14,14.G
13,0G
14,0= G
14,12+ P
14,12.G
11,0G
14,12= G
14,14+ P
14,14.G
13,12Additionneur de Sklansky en log
2(n)
Additionneur en temps (n
1/2)
42
Additionneur en temps (n
1/3)
Exercice
44
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'4k'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 metk'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
Q =k' k' k'
Additionneur de Ling
Pour S
6on précalcule p
6et p
6 k'
5G
5,3= g
5+ k'
5g
4+ k'
5k'
4g
3= a
5b
5+ (a
5+b
5)a
4b
4+ (a
5+b
5) (a
4+b
4)a
3b
3H
5,3= g
5+ g
4+ k'
4g
3= a
5b
5+ a
4b
4+ (a
4+b
4)a
3b
3H
5,3est plus rapide à calculer que G
5,346
Additionneurs Parallèles
• 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
• (13)10= 1*23+1*22+0*21+1*20 = >1101 en binaire naturel
=> 01 01 00 01 en CS ou bien
= 1*23+0*22+2*21+1*20
= > 01 00 11 01 en CS
0 , 1 , 2
, ,
, ,
, 2 2
2
10 1
0 1
0
a b
ns
ia
ib
is
ii i
n i
i i
n i
i i
B S
A
Cellule CS (Carry-Save)
• 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
48
• 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 f
0 0 0 e
1 0 e e'
2 1 ou 0
0
ou 1 e
3 1 e e'
4 1 1 e
Additionneur parallèle CS
CS CS CS
s0
a2 b2 a1 b1 a0 b0
s2 s1
g f g f g f
0
50
Table de vérité
h = majorité (a,b,c)
g = majorité (somme(a,b,c),d,e) a + b + c + d + e = 2*h +
2*g + f
Implantation : additionneur parallèle CS
52
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)
Additionneur parallèle
ai {0,1,2}
Codage : ai:{ai1,ai2} / ai1+a12 = ai 0 : 00
1 : 01 ou 10 2 : 11
CS
Implantation Cellule CS (Carry-Save)
54
Variantes
Additionneurs de réels
56
Nombre réels
• Codage des réels : virgule flottante
• flottant stocké sous la forme M * B
E– M : Mantisse ; B : Base ; E : Exposant
• exemple : 123 . 10
3= 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
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
• 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
58
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
Exemple : 452,5 + 117,5
60
452,5=
A=1.11000100100000000000000*2
8117,5=
B=1.11010110000000000000000*2
6A=1.11000100100000000000000*2
8B=0.0111010110000000000000000*2
8452,5=
117,5=
A+B = 10.0011101000000000000000000*2
8= 1.0001110100000000000000000*2
9Addition 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
Exemple : 452,5+117,5
62
A=1.11000100100000000000000*2
8B=1.11010110000000000000000*2
6Alignement des mantisses
B= 0.01110101100000000000000|00*2
8Addition des mantisses alignées
A=1.110001001000000000000000000*2
8+B=0.011101011000000000000000000*2
8S=10.001110100000000000000000000*2
8Normalisation de la mantisse
S'=1.000111010000000000000000000*2
9Arrondi de la mantisse
S'=1.00011101000000000000000*2
9452,5=
117,5=
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
Architecture : huit blocs
Bloc 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.
64
Architecture
452,5+117,5Bloc1 Bloc2
Décal.1 Compl.
Addit. 1
Décal.2 Compt. zéros
Addit. 2
Multiplieurs
66
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
Multiplieur
68
A
3B
0A
2B
0A
1B
0A
0B
0A
3B
1A
2B
1A
1B
1A
0B
1A
3B
2A
2B
2A
1B
2A
0B
2A
3B
3A
2B
3A
1B
3A
0B
3PP1 PP2 PP3 PP4
PP1 + PP2 = R1 =>
R1 + PP3 = R2 =>
R2 + PP4 = P
+
Ri Ai-1 Bj
Ri+1
P = A * B
A=A3 A2 A1A0 B=B3 B2 B1 B0
P=P7P6P5P4P3 P2 P1P0
B
3B
2B
1B
0A
3A
2A
1A
0*
P
7P
6P
5P
4P
3P
2P
1P
0Multiplieur
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
A0 A1
A2 A3
A0 A1
A2 A3
A0 A1
A2 A3
A0 A1
A2 A3
0
0
0
0
Multiplieur naïf (5 x 6)
25 adders, chemin critique 13 adders
70Multiplieur amélioré
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
Multiplieur de Braun
72
A
4B
0A
3B
0A
2B
0A
1B
0A
0B
0A
4B
1A
3B
1A
2B
1A
1B
1A
0B
1A
4B
2A
3B
2A
2B
2A
1B
2A
0B
2A
4B
3A
3B
3A
2B
3A
1B
3A
0B
3B
5B
4B
3B
2B
1B
0A
4A
3A
2A
1A
0*
P
9P
8P
7P
6P
5P
4P
3P
2P
1P
0A
4B
4A
3B
4A
2B
4A
1B
4A
0B
4A
4B
5A
3B
5A
2B
5A
1B
5A
0B
5Avec P0= A0B0, P1=A1B0+A0B1, P2 = A2B0+A1B1+A0B2, etc…
Multiplieur de Braun
Multiplication Signée (complément à 2)
74
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
Multiplieur séquentiel 1
76
A 00000000
R2 R1
+ B
8 8
8
8
8
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 R3R2R1
R3R2R1 0 0111 0000 Décalage de B => B=(0101) +A 1110 b0=1 => (R2 + A -> R3R2) ---
R3R2R1 1 0101 0000 Décalage de R3R2R1
R3R2R1 0 1010 1000 Décalage de B => B=(0010) +0 0000 b0=0 => (R2 + 0 -> R3R2) ---
R3R2R1 0 1010 1000 Décalage de R3R2R1
R3R2R1 0 0101 0100 Décalage de B => B=(0001) +A 1110 b0=1 => (R2 + A -> R3R2) ---
R3R2R1 1 0011 0100 Décalage de R3R2R1
Avec addition de A sur les poids forts et décalage
Multiplieur séquentiel 2
78
A 00000
R2 R1
+ B
4 4
4
4
4
R3
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 R3R2R1
R3 R2 R1 0 0111 0101 b0(R1)=1 => (R2 + A -> R3R2) +A 1110
---
R3 R2 R1 1 0101 0101 Décalage de R3R2R1
R3 R2 R1 0 1010 1010 b0(R1)=0 => (R2 + 0 -> R3R2) +0 0000
---
R3 R2 R1 0 1010 1010 Décalage de R3R2R1
R3 R2 R1 0 0101 0101 b0(R1)=1 => (R2 + A -> R3R2) +A 1110
---
R3 R2 R1 1 0011 0101 Décalage de R3R2R1 R3 R2 R1 0 1001 1010 Fin