La présentation est en train de télécharger. S'il vous plaît, attendez

La présentation est en train de télécharger. S'il vous plaît, attendez

1 Additionneurs. 2 Rappel sur l'écriture des entiers en base 2 Entiers positifs Entiers relatifs (complément à 2)

Présentations similaires


Présentation au sujet: "1 Additionneurs. 2 Rappel sur l'écriture des entiers en base 2 Entiers positifs Entiers relatifs (complément à 2)"— Transcription de la présentation:

1 1 Additionneurs

2 2 Rappel sur l'écriture des entiers en base 2 Entiers positifs Entiers relatifs (complément à 2)

3 3 C i+1 A i B i CiCi SiSi Additionneur "Full Adder" (FA) C i+1 = A i B i + A i C i + B i C i = majorité(A i,B i,C i ) C i+1 = A i B i + C i ( A i B i ) S i = A i B i C i AiBiCiAiBiCi C i+1 S i La 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+1

4 4 C i+1 = 1 si retenue Ci+1 = AiBi + AiCi + BiCi C o =0 A0B0A0B0 A1B1A1B1 A2B2A2B2 A3B3A3B3 C0C0 C1C1 C2C2 C3C3 C4C4 S0S0 S1S1 S2S2 S3S3 Ci+1 = AiBi + Ci ( Ai Bi) Si = Ai Bi Ci I- Additionneur à propagation de retenue S = A + B A=A 3 A 2 A 1 A 0 B=B 3 B 2 B 1 B 0 S=R S 3 S 2 S 1 S 0 La retenue se propage à travers tous les étages Délai = O(n)

5 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 6 Cellule de CSA Ci+1 = AiBi + Ci ( Ai Bi) Si = Ai Bi Ci

7 7 Carry select adder CSA : Délai n 1/ t2 t3t2t3t4t2t3t4t5 t3t4t5t6 t1 t2t1

8 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 0 1

9 9 III Additionneur à retenue bondissante Idée : Si A i =B i =0, C i+1 =0 : pas de retenue quelque soit C i Si A i =B i =1, C i+1 =1 : il y a forcément une retenue, quelque soit C i Si A i B i,, 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 Cin Cin Somme –Dans les autres cas, la retenue sortante peut être calculée indépendamment de la retenue entrante

10 10 Carry Skip ADDER A i,B i, i=23,…,16 A i,B i, i=15,…,8A i,B i, i=7,…,0 & calcule : (A 0 B 0 ).(A 1 B 1 )…. (A 7 B 7 ) CnCn + & + & + & C0C0 P7 P15 P23 Temps de calcul : plus long temps de propagation dune retenue : une retenue se propage depuis le rang i où elle est générée (et pour lequel Gi=1) jusquau rang où la retenue suivante est générée Un bloc est constitué dun additionneur à propagation de retenue et dun « circuit » détectant si pour chaque bit i du bloc on a AiBi,

11 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 CnCn + & + & + & C0C0 P7 P15 P23

12 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 3Groupe 2Groupe 1

13 13 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 dun bloc de k additionneurs : t1*k temps de propagation à l'aide des comparateurs: t2 (comparaison + "et" + "ou") 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.

14 14 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 x 0 = (2*n*t1/t2) 1/2 f convexe sur R + => m optimal : 2 valeurs entières qui encadrent x 0 Temps total = O(n 1/2 ) exemple : additionneur de 60 bits, t1=t2 => x 0 =120 1/2 =10,95 m = 10 ou m =12 10 blocs de 6 bits ou 12 blocs de 5 bits

15 15 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: –t r - temps de propagation de la retenue sur un seul bit –t s (k) – Temps pour sauter un groupe taille k (la plupart du temps - indépendant de k) –t b – 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

16 16 Carry Skip ADDER : taille des blocs T total =(k-1)t r +t b +(n/k-2)(t s +t b )+(k-1)t r Exemple - implémentation 2 niveaux –t r = t s +t b = 2 G ( G = délai d'une porte) –Ttotal=(4k+2 n /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 G au lieu 62 G pour un additionneur à propagation de retenue

17 17 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 existant pour déterminer les taille de groupes optimales pour différentes technologies et implantations (càd différentes valeurs du ratio (t s +t b )/t r )

18 18 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 ) et s'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)

19 19 Optimiser les taille de groupe k 1, k 2, …, k L – 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 : 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

20 20 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 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 T carry (u,v) 9 t r

21 21 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)

22 22 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 p i-1.p i-2.p i-3....p 0.c 0 c 1 = g 0 + p 0.c 0 c 2 = g 1 + p 1.g 0 + p 1.p 0.c 0 c 3 = g 2 + p 2.g 1 + p 2.p 1.g 0 + p 2.p 1.p 0.c 0 c 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 0 Additionneur à retenue anticipée : CLA

23 23 Additionneur à 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 i c i = g i-1 + p i-1.g i-2 + p i-1.p i-2.g i p i-1.p i-2.p i-3....p 0.c 0

24 24 Additionneur à retenue anticipée c0 g0p0g1p1g2p2g3p3 c4 s0s1s2s3 c3 c2c1 g.p. C.L.U. a0b0a1b1a2b2a3b3 CLU : Carry Look-ahead Unit p0p1p2p3 S i = p i c i

25 25 Bloc g.p. p i = a i b i (propagation d'une retenue) g i = a i.b i (génération d'une retenue) g.p. aiai bibi pipi gigi

26 26 c4c3c2c1 c0 p3g3p2g2p1g1p0g0 Bloc CLU Délai : 2 portes c i = g i-1 + p i-1.g i-2 + p i-1.p i-2.g i p i-1.p i-2.p i-3....p 0.c 0

27 27 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) c0 c4 a0b0a1b1a2b2a3b3 c8 a4b4a5b5a6b6a7b7 c12 a8b8a9b9a10b10a11b11

28 28 V- Génération et propagation de groupe Soient g i, p i, P i,j G i,j dé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>ijk0) P i,k = P i,j.P j-1,k : propagation du rang k au rang 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 et S 0 =p 0 c 0

29 29 Cellule de Brent et Krung Propriétés : –La cellule est associative => nombreux assemblages possibles –Règle dassemblage : 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,k P i,k = P i,j.P j-1,k P i,j G i,j P j-1,k G j-1,k P i,k G i,k P i,k P i,j P j-1,k G i,k G i,j P i,j G j- 1,k G i,i = g i P i,i = p i n i j k 1

30 30 Calcul arborescent de la retenue de sortie 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 S i = p i G i-1, c i+1 = G i,0 + P i,0. c 0

31 31 Additionneur Brent & Kung en temps log 2 (n)+2 Gi calcul pi et gi s i = p i G i-1,0 C 16

32 32 Additionneur de Brent & Kung temps

33 33 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.

34 34 Additionneur de Brent & Kung modifié 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,0 G 14,0 = G 14,12 + P 14,12.G 11,0 G 14,12 = G 14,14 + P 14,14.G 13,12

35 35 Additionneur de Sklansky en temps log 2 (n) Délai : log2(n) contre log2(n)+2 Nombre de celules : 32 contre 27

36 36 Additionneur en temps (n 1/2 )

37 37 Additionneur en temps (n 1/3 )

38 38 Exercice

39 39 Additionneur de Ling (1981) k i = le retenue a été tuée au rang i = a i '. b i ' Remarque : g i = k' i g i Calcul de la 6ième retenue S 6 = p 6 G 5,0 G 5,0 = G 5,3 + P 5,3 G 2,0 G 5,3 = g 5 + k' 5 g 4 + k' 5 k' 4 g 3 G 2,0 = g 2 + k' 2 g 1 + k' 2 k' 1 g 0 P 5,3 = k' 5 k' 4 k' 3 Le délai de S 6 est déterminé par G 5,0 dont tous les termes contiennent k' 5 sauf le premier. Or g 5 = k' 5 g 5. On met k' 5 en facteur : S 6 = p 6 k' 5 H 5,0 (H i,0 pseudo-retenue au rang i) H 5,0 = H 5,3 + Q 5,3 H 2,0 H 5,3 = g 5 + g 4 + k' 4 g 3 H 2,0 = g 2 + g 1 + k' 1 g 0 Q 5,3 = k' 4 k' 3 k' 2

40 40 Additionneur de Ling Pour S 6 on précalcule p 6 et p 6 k' 5 G 5,3 = g 5 + k' 5 g 4 + k' 5 k' 4 g 3 = a 5 b 5 + (a 5 +b 5 )a 4 b 4 + (a 5 +b 5 ) (a 4 +b 4 )a 3 b 3 H 5,3 = g 5 + g 4 + k' 4 g 3 = a 5 b 5 + a 4 b 4 + (a 4 +b 4 )a 3 b 3 H 5,3 est plus rapide à calculer que G 5,3

41 41 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 Exemple : (13) 10 = 1*2 3 +1*2 2 +0*2 1 +1*2 0 = >1101 en binaire naturel => en CS = 1*2 3 +0*2 2 +2*2 1 +1*2 0 = > en CS Additionneurs Parallèles

42 42 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 abcde hgf

43 43 Additionneur parallèle CS CS s0 a2b2a1b1a0b0 s1 s2 gggfff 0

44 44

45 45 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

46 46 Implantation : additionneur parallèle CS FA abcd h gf g g e h = majorité (a,b,c) f = somme (a,b,c,d,e) g = majorité (somme(a,b,c),d,e)

47 47 Additionneur parallèle ai {0,1,2} Codage : ai:{ai1,ai2} / ai1+a12 = ai 0 : 00 1 : 01 ou 10 2 : 11 CS

48 48 Implantation Cellule CS (Carry-Save)

49 49 Variantes

50 50 Additionneurs de réels

51 51 Nombre réels Codage des réels : virgule flottante flottant stocké sous la forme M * B E – M : Mantisse ; B : Base ; E : Exposant exemple : = 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 SMEbM

52 52 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 : –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 nest pas 0 et un seul chiffre avant la virgule ex : 3,25 10 =11,01 = 1,101 * 2 1

53 53 Virgule Flottante Mantisse : Comme le bit de poids fort de la mantisse est nécessairement 1, on ne lindique pas (gaspillage de place). Il est implicite –partie fractionnaire = f1f2 …fn m = 1,f1f2…fn –nombre x = (-1) SM * 1,M * 2 Eb-127 Exemple – x = (-2,5) 10 = (-1,01*2 1 ) 2 – SM = 1 ; – E= 1 => Eb= 128 = ; – m=1,01 => M = 010…… ……0

54 54 Exemple : 452, ,5 452,5= A= * ,5= B= *2 6 A= *2 8 B= * ,5= 117,5= A+B = *2 8 = *2 9

55 55 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

56 56 Exemple : 452,5+117,5 A= *2 8 B= *2 6 Alignement des mantisses B= |00*2 8 Addition des mantisses alignées A= *2 8 +B= *2 8 S= *2 8 Normalisation de la mantisse S'= *2 9 Arrondi de la mantisse S'= * ,5= 117,5=

57 57 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

58 58 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.

59 59 Architecture voir : 452,5+117,5 Bloc1Bloc2 Décal.1 Compl. Addit. 1 Décal.2 Compt. zéros Addit. 2

60 60 Multiplieurs

61 61 Multiplication binaire Multiplicande Multiplieur Produit partiel Produit partiel Produit partiel Produit partiel *

62 62 A 3 B 0 A 2 B 0 A 1 B 0 A 0 B 0 A 3 B 1 A 2 B 1 A 1 B 1 A 0 B 1 A 3 B 2 A 2 B 2 A 1 B 2 A 0 B 2 A 3 B 3 A 2 B 3 A 1 B 3 A 0 B 3 PP1 PP2 PP3 PP4 PP1 + PP2 = R1 => R1 + PP3 = R2 => R2 + PP4 = P + RiAi-1 Bj Ri+1 Multiplieur P = A * B A=A 3 A 2 A 1 A 0 B=B 3 B 2 B 1 B 0 P=P 7 P 6 P 5 P 4 P 3 P 2 P 1 P 0 B 3 B 2 B 1 B 0 A 3 A 2 A 1 A 0 * P 7 P 6 P 5 P 4 P 3 P 2 P 1 P 0

63 63 A 3 B 0 A 2 B 0 A 1 B 0 A 0 B 0 A 3 B 1 A 2 B 1 A 1 B 1 A 0 B 1 A 3 B 2 A 2 B 2 A 1 B 2 A 0 B 2 A 3 B 3 A 2 B 3 A 1 B 3 A 0 B 3 Multiplieur

64 64 Multiplieur naïf (5 x 6) 25 adders, chemin critique 13 adders

65 65 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

66 66 A 4 B 0 A 3 B 0 A 2 B 0 A 1 B 0 A 0 B 0 A 4 B 1 A 3 B 1 A 2 B 1 A 1 B 1 A 0 B 1 A 4 B 2 A 3 B 2 A 2 B 2 A 1 B 2 A 0 B 2 A 4 B 3 A 3 B 3 A 2 B 3 A 1 B 3 A 0 B 3 Multiplieur de Braun B 5 B 4 B 3 B 2 B 1 B 0 A 4 A 3 A 2 A 1 A 0 * P 9 P 8 P 7 P 6 P 5 P 4 P 3 P 2 P 1 P 0 A 4 B 4 A 3 B 4 A 2 B 4 A 1 B 4 A 0 B 4 A 4 B 5 A 3 B 5 A 2 B 5 A 1 B 5 A 0 B 5 Avec P 0 = A 0 B 0, P 1 =A 1 B 0 +A 0 B 1, P 2 = A 2 B 0 +A 1 B 1 +A 0 B 2, etc…

67 67 Multiplieur de Braun 24 adders, chemin critique 9 adders

68 68 Multiplication Signée (complément à 2)

69 69 Multiplieur séquentiel 1 (A) 1110 (B) R2R Initialisation de R1 et R2 +A* b0=1 => on ajoute A* R2R Décalage de B => B=(0101) +A* b0=1 => on ajoute A* R2R Décalage de B => B=(0010) +0*2 2 b0=0 => on ajoute 0* R2R Décalage de B => B=(0001) +A* b0=1 => on ajoute A* R2R Fin Avec addition de A sur le ième bit

70 70 Multiplieur séquentiel 2 (A) 1110 (B) R3R2R Initialisation de R3 R2 R1 +A 1110 b0=1 => (R2 + A -> R3R2) R3R2R Décalage de R3R2R1 R3R2R Décalage de B => B=(0101) +A 1110 b0=1 => (R2 + A -> R3R2) R3R2R Décalage de R3R2R1 R3R2R Décalage de B => B=(0010) b0=0 => (R > R3R2) R3R2R Décalage de R3R2R1 R3R2R Décalage de B => B=(0001) +A 1110 b0=1 => (R2 + A -> R3R2) R3R2R Décalage de R3R2R1 R3R2R 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

71 71 Multiplieur séquentiel 3 (A) R3 R2 R Initialisation de R3R2R1 (B->R1) +A 1110 b0(R1)=1 => (R2 + A -> R3R2) R3 R2 R Décalage de R3R2R1 R3 R2 R b0(R1)=1 => (R2 + A -> R3R2) +A R3 R2 R Décalage de R3R2R1 R3 R2 R b0(R1)=0 => (R > R3R2) R3 R2 R Décalage de R3R2R1 R3 R2 R b0(R1)=1 => (R2 + A -> R3R2) +A R3 R2 R Décalage de R3R2R1 R3 R2 R Fin

72 72 Multiplieur séquentiel 4 architecture SHIFT_MULT of MULT is begin 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; Product<=M&B; DONE<='1' endprocess; end SHIFT_MULT; entity MULT is PORT( A_PORT,B_PORT : in bit_vector(3 downto 0); Product : out bit_vector(7 downto 0); CLK : in CLOCK. START : in BIT; DONE : out BIT; ); end MULT; A_PORTB_PORT START CLK M_OUTDONE if (B(0) = 1)

73 73 Description structurelle Mux1 Mux2 Mux3 Mux4 Load A_Reg Load B_Reg Clear Count_Reg Load Count_Reg Clear Mult Load Mult Adder Schift 1 Schift 2 DONE Next State Control Unit S0&START=1S0&~(START=1) S1&COUNT<4 S1&~(COUNT<4) S2&B(0)=1 S2&~(B(0)=1) S3 Count_Reg Adder Mux1 M_Reg B_Reg A_reg State Reg Mux2 Mux3Mux4 Comp Shift2Shift1 Concat CLK DONEProduct B_PORT A_PORT B_reg(0) Compar.LT M(0)

74 74 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"; DONE:='1'; M:=M+A B(0) 1 B:=SHR(B,M(0)); M:=SHR(M,'0'); COUNT:=COUNT+1;

75 Synthèse contrôle CONDITIONVALEURACTIONS Etat Pr é sent S0START=1 T F A:=A_PORT; B:=B_PORT; COUNT:=0; DONE:='0'; M:="00000"; S1 COUNT<4 T F DONE:='1'; S1 S0 S2 S0 S2B(0)=1 T F M:=M+A S3 B:=SHR(B,M(0)); M:=SHR(M,'0'); COUNT:=COUNT+1; S1 Etat Futur

76 76 Synthèse contrôleur Mux1 Mux2 Mux3 Mux4 Load A_Reg Load B_Reg Clear Count_Reg Load Count_Reg Clear Mult Load Mult Adder Schift 1 Schift 2 DONE Next State S0&START=1S0&~(START=1) S1&COUNT<4 S1&~(COUNT<4) S2&B(0)=1 S2&~(B(0)=1) S3 State Reg DONE Start B_reg(0) Compar.LT Chemin de données

77 77 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 : … ….. =.… Donc : au passage 01 on rajoute A au passage 10 on enlève A

78 78 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 (A N et A N-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.

79 79 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

80 80 Exemple : N=5, P= (-5) * (+2) Etapes B BC PH PLCpt soustraction , ,3, nop addition , soustraction , nop 2,3, Résultat : b est le complément à 2 de = 10d càd -10 B= -5 (11011b) A= +2 (00010b). Le complément à 2 de A est b

81 81 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.

82 82 Multiplieur virgule flottante Exemple : P= A*B= 452,5*117,5 Signe du produit : "et" des bits de signe Exposant du produit : Somme des exposants Eb(P)= E(P)+127 = Eb(A)-127+Eb(B) = Eb(A)+Eb(B)-127 Mantisse du produit : Produit des mantisses et recadrage => modification de l'exposant

83 83 Division

84 , Soustraction 5 bits Exemple : 11 / 9 Division Binaire ,

85 Q R R , Si R>D alors Q=1 et R-D sinon Q=0 et R Diviseur S = A / D A=A 3 A 2 A 1 A 0 D=D 3 D 2 D 1 D 0 S=S 7 S 6 S 5 S 4, S 3 S 2 S 1 S 0

86 86 R RD Si alors Ci+1 Ci - Si D - R R Si Ci Ci+1 + Diviseur

87 87 Diviseur

88 88 Divisions multiplication de polynômes dans GF(2 n )

89 89 Espace des polynômes Suite de bits de p bits élément de [GF(2)] p coefficients du polynôme a p-1 x (p-1) +a p-2 x (p-2) +…+a 0 Ex : x 5 +0.x 4 +1.x 3 +0.x 2 +0.x+1 = x 5 +x 3 +1 P p-1 (ensemble des polys de degré < p) isomorphe à [GF(2)] p Attention : degré du poly = p-1 Structure d'espace vectoriel sur GF[2] Division polynomiale –P1(x) = P2(x).Q(x)+R(x) avec R(x)=0 ou deg(R)

90 90 Division de Polynômes Division dans [GF(2)] p P1(x) = P2(x).Q(x)+R(x) avec R(x)=0 ou deg(R)

91 91 Implantation du reste de la division de polynômes dans (GF[2]) n reste de la division de x 14 +x 12 +x 8 +x 7 +x 5 par x 5 +x 4 +x 2 +1 x 14 +x 12 +x 8 +x 7 +x 5 = ( x 5 +x 4 +x 2 +1) ( x 9 +x 8 +x 6 +x 4 +x 2 +x) + ( x 3 +x 2 +x) Quotient = Syndrome Reste

92 92 Implantation du reste de la division de polys division de x 14 +x 12 +x 8 +x 7 +x 5 par x 5 +x 4 +x 2 +1 Remarques : - on n'a besoin que 5 bits de résultats intermédiaire, le dividende peut être rentré en série - si le bit de poids fort du reste intermédiaire est 0 : on décale le reste intermédiaire en incluant un bit de plus du dividende 1 : on décale de reste intermédiaire en incluant un bit de plus du dividende et enlève (i.e. ajoute) le diviseur

93 93 Implantation du reste de la division de polys Remarques : - si le bit de poids fort = 0, décalage - si le bit de poids fort =1, décalage et addition du diviseur (càd soustraction) Entrée du dividende, puissance forte en tête i i k = x4x4 x3x3 x2x2 x1x1 x0x0 x5x division par x 5 +x 4 +x 2 +1 Quotient

94 94 Forme générale d'un diviseur i i k xnxn x0x0 a 0 x1x1 a 1 x n-2 a n-2 x n-1 a n-1 Division par a 0 + a 1 x + ……+ a n-1 x n-1 + x n a i la connexion existe si a i = 1 la connexion n'existe pas si a i = 0

95 95 Implantation de la multiplication de polynômes Multiplication de polynômes par un polynôme g(x) = x 3 +x+1 ABC i i 3 Exemple : soit à calculer i(x).g(x) avec g(x) = x 3 +x+1, i(x) = x 3 +x Initialement les bascules A,B,C sont à 0 tEABCSortie i3 = i2= i1= i0= x6x6 x5x5 x4x4 x3x3 x2x2 x1x1 x0x0 x3x3 xx0x0 1011

96 96 Implantations multiplication ABC i i 3 Exemple : g(x) = x 3 +x+1 A B C i i 3 Autre implantation x3x3 x1x1 x0x0 x3x3 x1x1 x0x0

97 97 Implantation : multiplication / division i i k 0 3 Multiplication par x+x 3, le résultat est divisé par 1+x 2 +x 5

98 98 Applications Codes correcteurs –L'information à coder est considérer comme un polynôme i(x) –par exemple : est considéré comme le poly x 4 +x 3 +1 –Codes polynomiaux : Codes linéaires Tous les mots de code sont des multiples de l'un d'eux (au sens produit de polynômes) –Le polynôme g(x) servant à construire le codage est appelé polynôme générateur (C'est le poly. qui code i(x) = 00….1)

99 99 Codage Soit à coder les mots de P k-1 (blocs de k bits) –Si le degré s de g(x) est fixé, il détermine la longueur du code –Si la longueur n du code est fixée, tout polynôme de degré s=n-k engendre un code Cn,k Codage par multiplication de polynômes –la fonction de codage f(i(x)) = i(x).g(x) permet de construire un code polynomial tel que –Cn,k = {c(x) = i(x).g(x) avec i(x) P k-1 et deg(g)=n-k}

100 100 Exemple Pour un code polynomial de longueur 5, de dimension 3 le polynôme générateur doit être de degré 5-3=2, ce peut être x 2, x 2 +1, x 2 +x+1 ou x 2 +x Soit par exemple g(x) = x 2 +x, en appliquant c(x)=i(x).g(x), on obtient ii(x)c(x) = i(x).g(x)c x 2 +x xx 3 +x x+1x 3 +x x2x2 x 4 +x x 2 +1x 4 +x 3 +x 2 +x x 2 +xx 4 +x x 2 +x+1x 4 +x

101 101 Matrice génératrice caractéristique Code linéaire, matrice génératrice. En codant la base canonique de P k-1 par la fonction de codage, on obtient une base de P n-1 => matrice génératrice caractéristique (très facile à obtenir) Base = {e1,e2,…..,ek} –e 1 (x) = x k-1 e 1 = (1 0 0 … 0) –…. –e k-1 (x) = xe k-1 = (0 0 0…1 0) –e k (x) =1 e k = (0 0 0 …..1) Ce qui donne : –x k-1 codé en x k-1.g(x), –x codé en x.g(x) –1 codé en g(x)

102 102 Matrice génératrice caractéristique Les polynômes de code obtenu forment un base du code, sous- espace vectoriel de dimension k de P n-1, chacun représente une des k colonnes d'une matrice génératrice G(g) que l'on peut écrire avec g(x) = x n-k +g k+1.x n-(k+1) +g n-1.x 2 +g n Les colonnes sont les vecteurs formés par les coef. des polys Si g(x)= x n-k +g k+1.x n-(k+1) +g n-1.x 2 +g n, il vient –(0 …. 0 1 g k+1 ……………g n ) correspond à g(x) –(0 …. 1 g k+1 ……………g n 0) correspond à x.g(x) –…… –(1 g k+1 ……………g n 0 …….0) correspond à x k-1.g(x)

103 103 Matrice génératrice caractéristique La matrice G(g) est donc de la forme Exemple : sur l'exemple précédent g(x) = x 2 +x qui correspond au vecteur ( ) de [GF(2)] 5, càd –g n = 0 –g n+1 = 1 –g n+2 = 1 –g n+3 = 0 –g n+4 = ……………… g k …………………0 g k+2 g k …………..0 …………………………… g n ………………… g k ……………………….g k+1 …………………………… ……………………………… 0……………………….0 g n

104 104 Codage systématique (par multiplication et division) Rappel : code systématique = info + bits Soit g(x) de degré s avec s=n-k, le codage se fait en 3 étapes (multipli. puis division de poly) Tout poly de code est de la forme –c(x) = (i 1.x n-1 +….+i k x n-k ) + a 1.x n-k-1 +…..+a n-k+1.x+a n-k = x n-k (i 1.x k-1 +….+i k ) + a 1.x n-k-1 +…..+a n-k+1.x+a n-k soit c(x) = x n-k. i(x) + a(x) avec a(x) =0 ou deg(a(x)) (n-k)-1 avec a(x) poly associé à la clef de contrôle.

105 105 Codage systématique (par multiplication et division) Codage 1/ calculer le produit x n-k.i(x) (cela revient à décaler les coef. de i(x) vers la gauche de n-k positions) 2/ calcul de la clef de contrôle –il faut que x n-k.i(x) + a(x) soit un mot du code i.e. de la forme i*(x).g(x) avec i*(x) P k-1 –ce qui implique x n-k.i(x) = i*(x).g(x) + a(x) on a deg(a(x)) = 0 ou deg(a(x)) (n-k)+1 donc a(x) est le reste de la division de x n-k.i(x) par g(x) 3/ concaténer x n-k i(x) et a(x) –En résumé : c(x) = x n-k.i(x) + (x n-k.i(x) mod g(x))

106 106 Règle du code systématique Pour construire Cn,r de générateur g(x) par un codage systématique, il faut pour chaque i(x) : –1/ calculer le produit x n-k.i(x) => coefs de plus haut degré –2/ diviser x n-k i(x) par g(x), le reste de la division est la clef a(x) associée à i(x) => coefs de plus petit degré –3/ ajouter (ce qui revient à concaténer) x n-k.i(x) et a(x)

107 107 Codage systématique : exemple Soit le code précédent C5,3 de poly g(x) = x 2 +x 1/ Calcul de x n-k.i(x) = x 5-3.i(x) = x 2.i(x) 2/Tableau des clefs a(x) par : x 2.i(x) = (x 2 +x).Q(x) +a(x) ii(x)x 2.i(x)=(x 2 +x) Q(x) +a(x)a(x) =(x 2 +x) x2x2 =(x 2 +x) 1 +xx 0 1 0xx3x3 =(x 2 +x) (x+1) +xx 0 1 1x+1x 3 +x 2 =(x 2 +x) x x2x2 x4x4 =(x 2 +x) (x 2 +x+1) +xx 1 0 1x 2 +1x 4 +x 2 =(x 2 +x) (x 2 +x) x 2 +xx 4 +x 3 =(x 2 +x) x x 2 +x+1x 4 +x 3 +x 2 =(x 2 +x) (x 2 +1) +xx

108 108 Codage systématique : exemple 3/ Codage par : c(x)=x 2.i(x)+a(x) ix 2.i(x)a(x)c(x)=x 2.i(x)+a(x)c x2x2 xx 2 +x x3x3 xx 3 +x x 3 +x x4x4 xx 4 +x x 4 +x x 4 +x x 4 +x 3 +x 2 xx 4 +x 3 +x 2 +x

109 109 Détection d'erreurs Par matrice de contrôle (cf. codes linéaires) Par division de polynômes : –Soit m(x) le message reçu m(x) = g(x).Q(x) + R(x) avec R(x) = 0 ou deg(R) < deg(g) si R(x) = 0, m(x) est un polynôme du code, m(x) accepté si R(x) 0, m(x) est un message erroné Fonction syndrome –soit s= deg(g), R(x) P s-1, R(x) = m(x) mod g(x) –l'application qui à chaque m(x) fait correspondre le reste de la division de m(x) par g(x) est une application linéaire de P n-1 dans P s-1 dont le code est le noyau, propre au code polynomial et toute matrice associée à cette application est une matrice de contrôle du code

110 110 CODES CYCLIQUES ou CRC Cyclic Redundancy Check Codes polynomiaux + propriété de stabilité par permutation circulaire des mots. Leur polynôme générateur divise x n +1 (n longueur du code). => construction immédiate de la matrice de contrôle Définition 1 : un code est dit cyclique si –il est linéaire –il est stable par permutation circulaire des mots. Notation – k, c C k (c) C, où k est une rotation de k positions Définition 2 : un code est cyclique si –code polynomial –le poly générateur divise x n +1

111 111 Contrôle des codes cycliques Comme code polynomial, un code cyclique admet un poly. de contrôle p(x) défini par x n +1 = p(x).g(x). Donc c(x) C p(x).c(x) mod( x n +1) = 0

112 112 Exemples de codes cycliques Exemples de polynômes générateurs - Code BCH (Bose-Chaudhuri - Hocquenghem ) l=15, k=10, e=3 R = 33% - Code Golay l=23, k=11, e=3 R = 52 % -X25 (HDLC) (ex: RNIS) - CRC-32 (Ethernet) : X 32 + X 26 + X 23 + X 22 + X 16 + X 12 + X 11 + X 10 + X 8 + X 7 + X 5 + X 4 + X 2 + X + 1

113 113 Exercice Soit un code polynomial de dimension 3 de poly. générateur x 2 +x+1 Quel est la taille des codes ? Calculer les codes par multiplication de polys et par matrice génératrice Proposer une structure pour le codage et le détection d'erreurs –implantation parallèle –implantation série –vérifier les structures sur des exemples significatifs.

114 114 Applications Test : –compression de réponses de test => syndrome –générateurs aléatoires


Télécharger ppt "1 Additionneurs. 2 Rappel sur l'écriture des entiers en base 2 Entiers positifs Entiers relatifs (complément à 2)"

Présentations similaires


Annonces Google