cours est imprimable

Op Art : tendance qui au sein de l'art cinétique privilégie les effets optiques générateurs d'illusion de mouvement (Larousse).

Version 1

Portée: De la porte logique aux opérateurs arithmétiques combinatoires. Pédagogie: Expérimenter, comprendre, améliorer complément de notes de cours. Méthode: Animer les figures du cours : Synthèse, simulation, diagramme, algorithme . Chapitre 1 : Full-Adder en CMOS Chapitre 2 : Additionneurs suivi de additionneurs spéciaux Chapitre 3 : Multiplieurs suivi de Multiplieurs en "CS" Chapitre 4 : Diviseurs suivi de Diviseurs rapides Chapitre 5 : Extracteurs de racine carrée suivi de Extracteurs rapides Chapitre 6 : Addition Virgule flottante Chapitre 7 : Fonctions exponentielle et logarithme suivies de sinus, cosinus, tangente, arc sinus et arc tangente Chapitre 8 : Représentation modulaire Ce cours existe également en Anglais.

Opérateurs Arithmétiques Page 1

Fonction "FA" en CMOS Technologie CMOS En technologie CMOS (Métal Oxyde Semiconducteur complémentaire) on utilise

des transistors canal N et des transistors canal P pour réaliser des fonctions logiques. La technologie CMOS est actuellement la technologie dominante du marché. Son principal intérêt par rapport à d'autres technologies comme le NMOS ou le bipolaire est une consommation d'énergie remarquablement faible. En fait les circuits CMOS ont un courant statique (quand ils sont au repos) pratiquement négligeable. Dans les figures ci-dessous : Un '1' logique est représenté électriquement par la tension d'alimentation Vdd (des valeurs courantes de Vdd sont +5V ou +3,3V ou +2,8V) et est coloré en rouge. Un '0' logique correspond à la tension de masse ou GND est coloré en bleu. Une connexion non reliée est colorée en jaune.

Remarquez que le transistor canal N conduit quand sa grille est au '1' logique, et que

le transistor canal P conduit quand sa grille est au '0' logique. Les touchespermettent de changer le dessin des transistors.

L'inverseur CMOS

L'inverseur est la porte CMOS la plus fréquente. Il est formé d'un transistor canal N et un transistor canal P, reliés par leurs drains. La figure ci-dessous en illustre le fonctionnement. Les couleurs sont toujours le rouge pour '1' logique et le bleu pour '0' logique. Une tension d'entré entre les deux cause un court-circuit en maintenant les deux transistors en conduction. Une telle tension est colorée en vert. Cliquer sur l'entrée "a" pour la faire passer de '0' à court-circuit (vert), puis à '1', puis de nouveau à '0'.

Remarquez que si l'entrée vaut '0' ou '1', un seul transistor conduit.


Délai et consommation de

l'inverseur CMOS

Nous venons de voir que l'inverseur n'a pas de dissipation d'énergie sauf lorsqu'il commute. En effet si l'entrée vaut '0' ou '1' il n'y a pas de chemin de conduction entre l'alimentation Vdd et la masse GND. Dans les conditions normales d'utilisation, le courant de court-circuit (inévitable lorsque l'entrée commute) dure très peu de temps, typiquement quelques picosecondes. La contribution du courant de charge ou décharge des capacités à la consommation est beaucoup plus importante. Les grilles G des transistors forment des capacités. Ces capacités sont d'ailleurs nécessaires au fonctionnement du transistor à effet de champs. Typiquement la capacité d'entré Cg vaut environ 10 fF. Si l'entrée a de l'inverseur est à reliée à Vdd au temps t1, cette capacité est chargée (charge Q = Cg

* Vdd). Si par la suite l'entrée est reliée à GND au temps t2 la capacité se décharge. Cette décharge produit un courant dans la grille de valeur I = dQ/dt = (Cg * Vdd)/(t2-t1). Bien que le courant de charge/décharge de grille soit faible, le courant total consommé par un circuit intégré complexe peut être important. Prenons un exemple : • Un microprocesseur moderne peut contenir 50 millions de transistors, soit

environ dix millions de portes. A chaque cycle environ 1% de ces portes commutent.

• Les fréquences d'horloge atteignent 500 MHz (temps de cycle 2 ns) avec une tension d'alimentation Vdd = 3.3V.

• Les fis connectant les portes ont une capacité parasite Cw bien plus grande que la capacité de grille Cg des portes. Chaque fois qu'une équipotentielle commute, toutes les capacités qui lui sont attachées doivent être chargées ou déchargées : Ctotal=Cg+Cw.

• La capacité d'un fil d'interconnexion atteint typiquement 1 pF Il est assez difficile d'estimer le courant dû aux courts-circuits, il est en général faible. En revanche le courant résultant de l'activité de commutation est important : I = (portes actives) *(Ctotal*Vdd) / dt = (1%*1.000.000) * (1pF*3.3V) / 2ns = 16 AEnfin le courant de repos dû aux fuites des transistors (pour une circuiterie conventionnelle) est très faible. Une mémoire statique SRAM de 2K*8 bits en CMOS laisse fuir µA au repos. La figure ci-dessous illustre le courant, ou déplacement d'électrons de l'inverseur CMOS . Si la tension d'entrée demeure à '1' ou à '0', soit le transistor canal P ou le transistor canal N est bloqué et il n'y a pas de courant. • Si l'entrée a commute, les grilles des deux transistors doivent être chargées ou

déchargées. Ceci est illustré par le passage d'un "électron" (de charge négative) venant de GND ou bien allant à Vss..

• Quand l'entrée commute, elle passe par des tensions faisant conduire les deux transistors pendant un temps très court. Le courant de court circuit résultant est illustré par le passage d'un électron de GND à Vss.

• Enfin la sortie est chargée ou déchargée à travers les transistors. La capacité qui y est attachée stocke deux "électrons".


La puissance dissipée par un circuit en logique CMOS conventionnelle est en conséquence directement proportionnelle à la fréquence des commutations, qui est la fréquence de l'horloge.

Simulation électrique de

l'inverseur CMOS

Quand vous cliquez dans le chronogramme ci-dessous, vous tracez la tension de l'entrée "a" de l'inverseur (tracé en rouge sur le chronogramme). La tension de la sortie "y" est alors calculée (tracée en bleu). Le courant traversant le transistor canal N est dessiné en vert et celui du transistor canal P en jaune. Pour stopper l'applet et figer le dessin, sortez le pointeur de la figure.

Portes de base

NOR et NAND Nous allons étudier maintenant les portes logiques de base en CMOS: successivement un NOR et un NAND à 2 entrées puis un NAND à 3 entrées. Comme pour toutes les portes CMOS, chaque entrée est connectée à la grille d'un transistor canal N et à la grille d'un transistor canal P. • Conventions de couleurs: Ce sont celles de l'Inverseur. Les connexions à Vdd

( '1' logique) sont en rouge, les connexions à GND ( '0' logique) sont en bleu, les connexions simultanément à Vdd et GND sont dessinées en vert. Enfin les connexions ni à Vdd ni à GND (flottantes) sont en jaune. Ces dernières couleurs n'ont pas d'image logique.

• Cliquer près d'une entrée pour changer sa valeur, notez le changement de l'état des transistors.

• La ligne de la table de vérité correspondant à cette combinaison de valeurs d'entrées est indiquée en blanc.

• En cliquant dans la table de vérité, on positionne les entrées aux valeurs de la ligne.

• Cliquer sur le haut de la table parcourt progressivement cette table.


Pour simplifier les applets, seuls des '1' et '0' logiques sont permis en entrée. Il n'est donc pas possible d'entrer des tensions provoquant un court-circuit entre Vdd et GND.

La porte NOR à 2 entrées

La porte CMOS à 2 entées est l'une des portes les plus simples pour illustrer le qualificatif complémentaire: les transistors canal P sont connectés en série alors que les transistors canal N sont connectés en parallèle. Les réseaux de transistors canal N et de transistors canal P sont complémentaires. Remarquez que si aucun des deux transistors canal P en série ne conduit, leur connexion commune est flottante (jaune). Cette valeur non logique ne pose toutefois pas de problème de fonctionnement logique car cette connexion n'est reliée à aucune grille de transistor.

La porte NAND à 2

entrées

Dans le NAND à 2 entrées, les transistors canal P sont reliés en parallèle alors que les transistors canal N sont reliés en série.

L'additionneur

binaireLa cellule "FA" (Full Adder) est formée de deux portes complexes connectées. Elle réalise une égalité arithmétique: la somme pondérée des 3 entrées "x", "y" et "z" a


toujours la même valeur que la somme pondérée des deux sorties "c" et "s", c'est à dire que " x + y + z = 2*c + s ". On peut aisément vérifier cette propriété grâce à la table de vérité.

Le réseau de transistors canal P est symétrique au réseau de transistors canal N. Un

circuit ayant cette propriété est appelé "miroir". Tous les additionneurs ont cette propriété qui découle d'un lien arithmétique entre le complément logique et le complément arithmétique. Enfin les sorties de ce circuit sont inversées. Cela découle d'une propriété de la technologie CMOS qui ne permet de faire facilement que les fonctions logiques non croissantes.


Additionneurs Cellule "FA"

Dans la cellule "FA", la somme pondérée des bits en sortie est égale à la somme pondérée des bits en entrée c'est à dire que " x + y + z = 2*c + s ". Les trois bits en entrée ont le même poids, disons 1 pour fixer les idées, le bit sortant "s" a le même poids que "x", "y" et "z" et "c", un poids double (c'est-à-dire 2). La cellule "FA" conserve la valeur numérique comme en électronique les nœuds conservent le courant. La cellule "FA" est également appelée "réducteur 3 ⇒2" car elle réduit le nombre de bits de 3 à 2 tout en conservant la valeur numérique.

Additionneur à

propagation L'addition est de très loin l'opération arithmétique la plus commune des processeurs numériques. D'abord parce que l'addition en tant que telle est très fréquente, ensuite parce que l'addition est la base d'autres opérations arithmétiques comme la multiplication, la division, l'extraction de racines et les fonctions élémentaires. Tout assemblage "cohérent" de cellules "FA" conserve la propriété: la somme pondérée des bits qui sortent vaut la somme pondérée des bits qui entrent. Pour obtenir l'additionneur S = A + B, il faut que les bits entrant soient ceux des nombres A et B et les bits sortant forment le nombre S. Le nombre de cellules "FA" nécessaires pour additionner les deux entiers A et B est le nombre de bits des nombres A et B.


Additionneur signé

La flèche verticale à côté du bouton de l'additionneur fait apparaître une double interprétation des vecteurs binaires A, B et S: entier sans signe (en haut) et entier signé dit en complément à 2 (en bas). Le même additionneur accepte ces deux interprétations à un détail près: le calcul du bit retenue sortante cn. On a le dilemme suivant:

• On ignore ce bit, on a un seul type d'additionneur et la somme S a autant de bits que les addendes A et B mais le débordement est possible.

• On tient compte de ce bit, pas de débordement possible mais l'additionneur d'entiers non signés est (légèrement) différent de l'additionneur d'entiers signés et S a un bit de plus que A et B.

On préfère généralement la première solution. Une flèche verticale apparaît à côté de S et passe de l'une à l'autre écriture de S: n bits ou n+1 bits.

Performance de l'additionneur à

propagation

Soit un additionneur à propagation à travers n cellules "FA", si on suppose que toutes les valeurs de A et B sont équiprobables et indépendantes, les résultats théoriques suivants viennent:

minimum moyen maximum

délai 0 log2(n) n

activité 0 3n / 4 n2 / 2 Le délai maximum (pire cas) n'est en général pas acceptable. Il est dû au chemin de la retenue qui traverse toutes les cellules "FA". Etudions donc le cheminement de la retenue.

Cheminement de la retenue

Pour chaque cellule "FA" un des 3 cas se produit : • la retenue ci+1 est mise à zéro, cas noté 'K', si ai = 0 et bi = 0 • la retenue ci+1 est mise à un, cas noté 'G', si ai = 1 et bi = 1 • la retenue ci+1 est propagée, cas noté 'P', si (ai = 0 et bi = 1) ou (ai = 1 et bi = 0). Dans ce cas ci+1 = ci. Ce dernier cas, défavorable pour le délai, est matérialisé par une flèche horizontale.

Ces trois cas 'K', 'G' et 'P' sont codés sur 2 bits. Une cellule "HA" calcule ces cas en fonction de ai et bi .


Cellule "BK"

(Brent et Kung) La cellule "BK" permet de calculer la retenue pour un bloc de 2 cellules "FA" ou plus généralement pour 2 blocs de cellules "FA".

Additionneur de

Sklansky Pour concevoir un additionneur rapide, on va calculer toutes les retenues ci par des arbres binaires de cellules "BK". L'additionneur de Sklansky construit des opérateurs additionnant des nombres de 2 bits, 4 bits, 8 bits, 16 bits, 32 bits, ... en assemblant chaque fois 2 additionneurs de taille inférieure. L'architecture est simple et régulière, mais n'est pas toujours la plus économique en nombre de cellules.

Chaque bit si = ai ⊕ bi ⊕ ci. Or ai ⊕ bi = '1' ssi la sortie de la cellule "HA" vaut 'P' . "HA" calcule ai ⊕ bi et ensuite le calcul de si demande une porte "XOR".


Additionneurs

rapides (Brent et Kung)

Il y a une seule règle de construction des arbres imbriqués de cellules "BK": Toute sortie de rang i est reliée à toutes les entrées de rang j ≤ i par un arbre planaire de cellules "BK", ce qui permet d'entrelacer les arbres des n sorties de très nombreuses façons en fonction du nombre de bit et du délai de l'additionneur. Ce délai s'étend de (n-1) à log2(n), bornes comprises.

Dans les arbres de cellules "BK" on peut troquer des cellules "BK" contre du délai:

moins il y a de délai (cellules "BK" à traverser) de calcul , plus l'additionneur utilise de cellules "BK".

• faites varier le nombre de bits et le délai • vérifier que les arbres suivent la règle de construction en cliquant sur un

signal, remarquer que chaque signal a un nom unique composé de 2 chiffres. • simuler un calcul de retenue en cliquant les touches. • voir les détails de la construction des arbres avec la touche "Détails" • voir la description en VHDL de l'additionneur avec la touche "VHDL". Pour

récupérer la description VHDL dans un éditeur de texte, la copier puis coller. • voir la table qui décrit ces arbres en cliquant la flèche verticale "vue" .

Additionneurs

de Kogge etLes arbres binaires de cellules "BK" des additionneurs de Kogge et Stone ne partagent pas. En conséquence la sortance des signaux est réduite au minimum au


Stone prix de cellules "BK" plus nombreuses, et comme le délai dépend de la sortance, il est un peu plus court.

Additionneurs de

Ling Dans un additionneur de Ling, les arbres de "BK" calculent une primitive appelée "pseudo retenue". Ceci permet d'éviter le calcul des pi et gi, mais impose en revanche un calcul supplémentaire pour obtenir la retenue à partie de la "pseudo retenue". L'astuce est que le délai de ce calcul supplémentaire est recouvert par le délai des cellules "BK". En conséquence l'additionneur est plus rapide (un peu). La synthèse VHDL de l'applet précédent en tire partie si l'option "Ling" est cochée.

Edition d'arbres de cellules "BK"

Pour éditer la table qui décrit les arbres de "BK", cliquer dans une case puis enter la valeur numérique de la case sélectionnée. Les valeurs incohérentes sont remplacées par 0, indiquant "pas de cellule". La flèche verticale dévoile les arbres.

Cellule "CS" Dans la cellule "CS", la somme pondérée des sorties est égale à la somme pondérée des entrées c'est à dire que "a + b + c + d + e = 2*h + 2*g + f ". La cellule "CS" n'est pas seulement un "réducteur 5⇒3", car en plus la sortie "h" ne dépend jamais de l'entrée "e".

Additionneur sans

La cellule "CS" ne propage pas la retenue de l'entrée "e" vers la sortie "h". Elle permet donc de réaliser des additionneurs sans propagation de retenue. Le nombre de cellules


propagation CS nécessaires est déterminé par le nombre de chiffres des entiers à ajouter. Cependant chaque chiffre est maintenant représenté sur 2 bits et la valeur du chiffre est la somme de ces deux bits. Les valeurs possibles des chiffres sont donc '0', '1' et '2' .

Ce système d'écriture des nombres entiers permet l'addition en un temps court et

indépendant du nombre de chiffre des opérandes. Cependant il utilise deux fois plus de bits que la notation standard. En conséquence une même valeur a plusieurs écritures (sauf 2

n – 1). Parmi toutes les écritures, celle

n'utilisant que des '0' et des '1' est unique. La flèche verticale à côté des nombres en change l'écriture sans changer la valeur. La flèche verticale à côté du bouton bascule la présentation en chiffres "CS" ou bits.

Additionneur hybride

On appelle "hybride" les opérateurs acceptant des écritures différentes. Dans l'additi-onneur ci-dessous, d'ailleurs très simple et très rapide, A est en binaire, alors que B et S sont en "CS


Convertisseur Un nombre A en "CS" a une seule représentation n'utilisant que des '0' et des '1' .

Convertir A de "CS" en binaire consiste à calculer cette représentation. Le convertisseur est un additionneur S = A' + A".

Un additionneur rapide comme Sklansky ou Kogge et Stone permet une conversion

rapide ; '0' donne 'K', '1' donne 'P' et '2' donne 'G' .


Additionneurs spéciaux

Additionneurs spéciaux

Certains algorithmes arithmétiques peuvent être réalisées en modifiant un additionneur. Par exemple : • si A + B < 2n alors S = A + B sinon S = A + B – 2n ; // addition modulo 2n • si A + B < 2n alors S = A + B sinon S = 2n – 1 ; // addition à saturation • si a/s alors S = A – B sinon S = A + B ; // additionneur/soustracteur • si A > B alors S = A sinon S = B ; // plus grand de A ou B • S = A + B ; S' = A + B + 1 ; // additionneur à 2 sorties S et S' • S = A + B ; S' = A + B + 1 ; S" = A + B + 2 ; // additionneur à 3 sorties • S = A + B – 1 ; S" = A + B + 1 ; // additionneur à encadrement • si A – B ≥ 0 alors S = A – B sinon S = B – A ; // valeur absolue de la différence • si A + B < 2n – 1 alors S = A + B sinon S = A + B – 2n + 1 ; // modulo 2n – 1 • si A + B < 2n + 1 alors S = A + B sinon S = A + B – 2n – 1 ; // modulo 2n + 1 Le coût et le délai du nouvel opérateur restent proches de ceux d'un additionneur.

Addition avec saturation

Si on néglige la retenue sortante cn alors un additionner donne A + B – 2n lorsque A + B est trop grand. Pour conserver la continuité de la sortie S et minimiser son erreur moyenne, on préfère parfois à l'addition modulo 2n l'addition avec saturation à la plus grande valeur que l'on peut écrire sur n bits : S = min ( A + B , 2n – 1) .

Additionneur/ soustracteur

Les additionneurs font spontanément les additions modulo 2n. Pour obtenir l'opposé -B d'un nombre B, on complémente logiquement tous ses bits puis on lui ajoute 1. L'addition de B et de -B obtenu ainsi donne 2n c'est à dire 0. On se sert de la retenue entrante c0 d'un additionneur pour ajouter 1 et de disjonctions pour complémenter chaque bits de B.


Débordement de l'addition/

soustraction d'entiers signés

Si les valeurs de la retenue cn et de la retenue cn-1 diffèrent, il y a un débordement et la somme S est arithmétiquement fausse:

• '0' '1' : il faut ajouter 2n à la somme pour la corriger (débordement négatif) • '1' '0' : il faut soustraire 2n à la somme pour la corriger (débordement positif)

Comme pour l'addition à saturation, les deux retenues cn et cn-1 permettent de choisir le plus grand nombre positif représentable ou le plus petit nombre négatif représentable en cas de débordement. S = min ( max ( A ± B , -2n-1) , 2n-1– 1) .

Comparateur Lorsqu'on effectue une soustraction S = A – B, le signe de S indique A ≥ B ou au contraire A < B, mais ne peut indiquer l'égalité. Si de plus on donne à c0 la valeur 'P' lors de la soustraction (et 'K' pour l'addition) alors la valeur 'P' de la retenue sortante cn ne peut qu'avoir été propagée sur toutes les positions et indique donc A = B, la valeur 'K' indique A < B et 'G' indique A > B. Aux entrées des disjonctions, 'K' donne '0', 'P' ou 'G' donnent '1' , cette transformation est représentée par un petit carré.


Plus grand de A

ou de B Pour comparer deux nombres A et B, il n'est pas nécessaire de calculer complètement leur différence S. Le signe de la différence S est donné par la retenue sortante. Ce comparateur est plus simple (moins de cellules "BK") et plus rapide (moins de sortance) qu'un soustracteur.

Additionneur a

retenue entrante retardée

Si la retenue entrante c0 d'un additionneur est prête plus tard que les entrées A et B, on utilise un additionneur à retenue entrante retardée est adéquat. Le délai entre l'entrée co et les sorties S est petit et indépendant du nombre de bits.


Si la retenue entrante co arrivait en même temps que les entrées A et B, une architecture semblable à celle de l'additionneur/soustracteur serait plus indiquée car moins coûteuse en cellules "BK".

Additionneur à deux sorties

Pour obtenir cet additionneur, on duplique les sorties de l'additionneur S = A + B + c0. Puis pour la sortie S on substitue à c0 la valeur '0' et pour l'autre sortie S' on substitue à c0 la valeur '1'. L'additionneur calcule simultanément S = A + B et S' = A + B + 1 .

La sortie des cellules "BK" vaut 'P', 'G' ou 'K' (2bits) et les entrées de portes ⊕ valent '0' ou '1' (1 bit), 'K' donne '0', 'G' donne '1' . • Pour le calcul de S = A + B, 'P' donne '0' . • Pour le calcul de S' = A + B + 1, 'P' donne '1'.


Additionneur à

trois sorties On veut calculer S = A + B, S' = A + B + 1, S" = A + B + 2. Pour calculer S et S" on calcule préalablement sans propagation de retenue deux nombres X et Y tels que X + Y = A + B. On obtient ainsi s0 et s" 0 . Ensuite on additionne les n-1 bits poids forts de X et Y avec l'additionneur à deux sorties précédent.

Le calcul de S' à partir de S et S", soit S' = S + 1 ou bien S' = S" – 1, est très simple.

• Le bit poids faible s' 0 est le complément de s0. • Pour les autres bits : si s0 = '0' alors s' i = si sinon s' i = s" i.

De semblable façon on peut également calculer S = A + B – 1 et


S" = A + B + 1 en calculant deux nombres X et Y tels que X + Y = A + B + 2n – 1 avec les cellules HA' , duales des cellules HA.

Valeur absolue de la différence

Avec quatre légères modifications l'additionneur de Sklansky à retenue entrante retardée rend S = A – B . • insérer des inverseurs pour complémenter B (ou bien A) • modifier la cellule "BK" calculant cn pour éliminer la valeur 'P' dans le signal

"rebouclage" ('K' donne '0', 'P' ou 'G' donnent '1' ). • insérer une ligne de cellules "BK" avec "rebouclage" en entrée • modifier ces dernières cellules pour soit complémenter logiquement le résultat S

('K' ou 'P' donnent '1' ) si "rebouclage" = '0' ou bien lui ajouter 1 ( 'P' ou 'G' donnent '1' ) si "rebouclage" = '1' .

si A + B

– ≥ 2n alors S = A + B

– + 1 sinon S = A + B–

–––––

De plus la valeur 'P' de cn indique que A = B, donc S = 0.

Addition en représentation

"signe valeur absolue"

Soit sa et sb les signes de A et B respectivement et Ma et Mb leurs valeurs absolues aussi appelées "magnitudes". L'addition de A et B est réalisée par l'addition de Ma et Mb si A et B sont de même signe, et par leur soustraction dans le cas contraire. Dans tous les cas le signe du résultat S est le signe de l'addende de plus grande magnitude. si (sa ⊕ sb) alors { Ms = Ma + Mb , ss = sa } // mêmes signes sinon si Ma ≥ Mb alors { Ms = Ma – Mb , ss = sa } sinon { Ms = Mb – Ma , ss = sb } L'additionneur de représentations "signe/valeur absolue" hérite à la fois de l'additionneur/soustracteur et de l'opérateur de valeur absolue de la différence.


La ligne horizontale "rebouclage" contrôle les cellules "BK" modifiées du bas :

si "rebouclage" = '2' alors Ms = Ma + Mb; // 'P' donne '0', 'G' donne '1' et 'K' donne '0'si "rebouclage" = '1' alors Ms = Ma – Mb; // 'P' donne '1', 'G' donne '1' et 'K' donne '0'si "rebouclage" = '0' alors Ms = Mb – Ma; // 'P' donne '1', 'G' donne '0' et 'K' donne '1'

Additionneur modulo 2n – 1

Un additionneur rend spontanément une somme modulo 2n. Avec une légère modification l'additionneur de Sklansky à retenue entrante retardée rend une somme modulo 2n – 1.


• si A + B < 2n – 1 alors S = A + B ; • si A + B ≥ 2n – 1 alors S = A + B + 1 modulo 2n ;

Dans les deux cas on a S = A + B modulo (2n– 1). La condition du test est donnée par la retenue cn: si cn = 'K' alors A + B < 2n – 1, si cn = 'P' alors A + B = 2n – 1, si cn = 'G' alors A + B > 2n – 1. Donc pour le signal "rebouclage" qui contrôle " +1" , 'K' donne '0', 'P' ou 'G' donnent '1' , comme pour la valeur absolue ci-dessus.

Additionneur modulo 2n + 1

• si A + B < 2n + 1 alors S = A + B ; • si A + B ≥ 2n + 1 alors S = A + B – 1 modulo 2n;

On se ramène à l'additionneur modulo 2n en calculant préalablement sans propagation de retenue deux nombres X et Y tels que X + Y = A + B + 2n – 1 + c0 avec les cellules HA' , duales de HA. La retenue entrante c0 vaut '0'. si X + Y < 2n+1 alors S = X + Y + 1 modulo 2n ; si X + Y ≥ 2n+1 alors S = X + Y modulo 2n ; Donc le signal "rebouclage" horizontal qui contrôle "+1" est le "nand" de xn et (cn = 'G' ). Le bit poids fort sn est le "and" de xn et (cn = 'P' ) .

Les valeurs de A et B vont de 0 à 2n. Les bits an et bn manquent en entrée de

l'additionneur ci-dessus. Ces deux bits manquant indiquent A = 2n et B = 2n respectivement. si A = 2n et B = 2n alors ( A + B ) modulo 2n + 1 = 2n – 1. si A = 2n et B < 2n alors A se réécrit ( 2n – 1 ) + 1, c'est à dire tous les bits ai sont forcés à '1' ainsi que la retenue entrante c0.


si A < 2n et B = 2n alors B se réécrit ( 2n – 1 ) + 1, c'est à dire tous les bits bi sont forcés à '1' ainsi que la retenue entrante c0.


Multiplieurs Multiplieur La multiplication vient en second pour la fréquence d'utilisation.

Porte "AND"

Une porte "AND" multiplie 2 bits. Pour multiplier 2 nombres A et X de n bits chacun, on utilise n2 portes "AND" qui multiplient chaque bit de A par chaque bit de X. La somme pondérée de ces n2 bits a bien comme valeur le produit P = A * X. Cependant cet ensemble de bits n'est pas un nombre, bien que sa valeur se calcule comme celle d'un nombre. Comme A < 2n et X < 2n, le produit P < 22n et s'écrit donc sur 2n bits.

Multiplication sans signe

Une structure régulière de portes "AND" et de cellules "FA" formant un assemblage "cohérent" permet d'obtenir les produits partiels puis de les réduire pour finalement obtenir le nombre P. Comme chaque cellule "FA" réduit le nombre de bits de 1 exactement (tout en conservant la valeur de P), la quantité de cellules "FA" strictement nécessaire est n2 – 2n (nombre de bits entrant – nombre de bits sortant). Cependant il y en a ici un peu plus car il entre aussi quelques '0' qu'il faut aussi réduire, plus précisément un '0' par chiffre de X. La flèche verticale "vue" dévoile ou bien cache le réseau des fil distribuant A et X. A chaque croisement de ces fils il y a une porte "AND".

Multiplication signée

Si le multiplicande A et le multiplieur X sont en complément à 2, alors les produits avec les bits de signe an-1 et xn-1 doivent être inversés et la constante 2n ajoutée pour obtenir le complément arithmétique des produits de X et A avec ces deux bits. Le bit de signe de P doit également être inversé.


Multiplieurs rapides

Plusieurs pistes conduisent à une amélioration de la vitesse: • Diviser le nombre de bits à réduire en utilisant des grandes bases. • Utiliser une structure cohérente de cellules "FA" en arbre. • Utilisation de cellules "CS", dont le pouvoir de réduction double de celui du

"FA" permet en outre les arbres binaires faciles à équilibrer. • Utiliser un modèle de délai fidèle pour construire les arbres. • Choisir un additionneur final rapide prenant en compte des délais d'entrée

inégaux

Codeur de Booth "BC"

Passer à une base de numération plus grande réduit mécaniquement le nombre de chiffres du multiplieur X. Voyons la base 4, qui a utilise deux fois moins de chiffres que la base 2 pour représenter le même nombre. Le "Code de Booth" ( ou "BC" ) est le code de redondance minimale, symétrique, en base 4. Les chiffres ∈ {-2, -1, -0, 0, 1, 2}. Le code sur 3 bits adopté ici, en "signe/valeur absolue", donne 2 notations pour le zéro.

Cependant les produits partiels sont calculés avec une cellule plus complexe qu'un "AND".

Cellule du convertisseur

de "BC"

Pour faciliter le produit d'un nombre par un chiffre "BC", on réécrit ce dernier en "signe/valeur absolue" grâce à une cellule "B2BC". La cellule "B2BC" convertit un chiffre "BC" en "signe/valeur absolue" pour le calcul de produits partiels. La somme est conservée: -2 × x3 + x2 + x1 = (-1)s × ( 2 × M2 + M1 ) ;


La conversion de X requiert deux fois moins de cellules "B2BC" que de bits de X.

Multiplieur des bits de A par un

chiffre "BC"

La multiplication par un chiffre "BC" ∈ {-2, -1, -0, 0, 1, 2} rajoute 2 bits à ceux de A: un pour avoir A ou bien 2A, un autre pour la retenue entrante en cas de soustraction. A étant signé, il faut éventuellement étendre son signe sur le bit ajouté.

La multiplication de A requiert autant de cellule "CASS" que de bit de A plus 1.

Le bit poids fort pn du produit partiel P est négatif. Pour cumuler ce bit à des bits

positifs, il faut l'inverser en sortie de la cellule "CASS".

Génération des produits partiels

La première étape de la multiplication génère à partie de A et de X des bits dont la somme pondérée vaut le produit P. Le bit de poids fort de P est positif pour la multiplication d'entiers sans signe, et négatif pour la multiplication d'entiers en complément à 2. L'applet propose cinq façons de calculer les produits partiels :

• Sans signe: les opérandes A et X sont en binaire. • Signé: les opérandes A et X sont en complément à 2. • Selon l'approche de Baugh et Wooley : A et X sont en complément à 2. • Avec le "code de Booth": X est recodé en base 4 (code de Booth modifié) • Enfin utilisant la "notation de Booth canonique": code de Booth modifié avec le

maximum de '0'


Les quatre derniers calculs sont signés.

Réduction des

produits partiels La deuxième étape de la multiplication réduit les produits partiels de l'étape précédente à deux nombres, en conservant la somme pondérée des bits. Ces deux nombres seront additionnés dans la troisième étape. La synthèse des arbres de Wallace suit l'algorithme de Dadda, qui garanti le minimum d'opérateurs de réduction. Si de plus on impose d'effectuer les réductions le plus tôt ou le plus tard possible, alors la solution est unique et synthétisée toujours de la même façon. Les deux nombres binaires à ajouter dans la troisième étape peuvent être vus comme un seul nombre en "CS".

Exemple d'arbre

de Wallace L'applet suivant réduit 82 produits partiels (par exemple le produit de deux nombres sans signe de 8 bits chacun). Les arbres de Wallace réduisent "au plus tard" (touche "tard" de l'applet ci-dessus). La somme pondérée des 16 bits qui sortent vaut toujours la somme pondérée des 64 bits qui entent.


La case à cocher en haut à gauche autorise l'usage de cellules "CS" dans la réduction.

La flèche verticale supprime/rétabli l'additionneur final. Le résultat est en binaire avec l'additionneur et en "CS" sans l'additionneur. Le délai de l'addition finale (Kogge et Stone) est comparable à celui de l'arbre de réduction.

Délais du "FA"

Un modèle plus fidèle du délai de la cellule "FA" permet de diminuer encore le délai des arbres de réduction des produits partiels d'un multiplieur. L'entré "x" est prise comme référence des délais de la cellule "FA", dxy et dxz sont les retards tolérés des entrées "y" et "z", enfin dxc et dxs sont les délais de calcul de la retenue "c" et de la somme "s" par la cellule "FA". Le chronogramme trace les instants où les signaux internes sont prêts, les sorties vers l'additionneur final sont tracées en magenta. La flèche verticale "vue" permet de tracer un trait jusqu'à l'instant où ces signaux sont pris (c'est à dire les intervalles de temps perdus) ou encore les cellules "FA" et "HA" des arbres de réduction.


Additionneur final à "temps

d'arrivée inégaux"

La figure précédente montre que les entrées de l'additionneur final ne sont pas toutes prêtes en même temps. Typiquement les poids faibles sont tôt, les poids fort un peu moins, et les bits du milieu sont très en retard. On peut tenir compte de ces différents temps d'arrivée (indiqués par un trait magenta) dans la construction des arbres de cellules "BK" calculant les retenues de l'additionneur final. Pour modifier le profil des temps d'arrivée, tracer des traits dans la figure en maintenant la touche "ctrl" enfoncée.

Multiplieurs en "CS"

Produits partiels d'opérandes en

"CS"

Le multiplieur X et le multiplicande A sont tous les deux en "CS", c'est à dire avec des chiffres ∈ { 0, 1, 2}. On génère des chiffres dont la somme pondérée est égale à A * X. Pour assurer que ces chiffres sont des bits (faciles à additionner), il est nécessaire que dans A ou bien dans X tout chiffre '2' soit précédé à droite par un '0'. Donc A ou bien X nécessite une réécriture.


Réduction des produits partiels

Les produits partiels de la multiplication de nombres en "CS" sont simplement des bits, réduits de la même façon que pour les multiplieurs précédents.

Cellule "xCS" La cellule "xCS" permet de calculer le produit de deux chiffres "a" et "x" en "CS". Son équation arithmétique est "2 × y + 2 × b + i = x × a + c + z". De plus les sorties "b" et "y" ne dépendent jamais des entrées "c" ou "z" (pas de propagation). En effet "c + z" ne prend pour valeur que 0 ou 1 (il est impossible que "c + z" vaille 2) et "a × x" ne prend pour valeur que 0, 1, 2 ou 4. Seul la valeur 1 pourrait provoquer une propagation, mais elle n'est possible que si c et z sont tous les deux 0.


Codeur "CS2CS"

Le transcodeur "CS2CS" passe de "CS" à "CS" en garantissant qu'en sortie un '2' est toujours précédé à droite par un '0'.

Cette propriété permet de calculer les produits partiels binaires avec un multiplicande A et un multiplieur X tous les deux en "CS".

Codeur "CS2BC"

Le transcodeur "CS2BC" passe de "CS" à "BC" , c'est à dire du code à retenue conservée base 2 au code symétrique de redondance minimum base 4 (ou "Code de Booth").

Multiplieurs par des constantes

Multiplication d'un nombre

par une série de constantes

La transformée de Fourier discrète, la transformée Cosinus ou son inverse, le filtre numérique, etc..., contiennent des multiplications d'une variable X par plusieurs constantes C1, C2, .. Cn. La factorisation de ces constantes permet de réduire le nombre d'additions/soustractions de ces multiplications, parfois très fortement. L'applet ci-dessous calcule Y1 = X*C1, Y2 = X*C2, .. Yn = X*Cn...



Diviseurs Pesée du pain

avec restauration sans restauration,

pesée RST

On veut calculer Q = A ÷ D. Par un coup de chance extraordinaire on dispose d'une balance, d'un pain de mie dont le poids est justement A et enfin d'une série de poids de valeur D, 2D, 4D, 8D, ... 2i

*D marqués respectivement avec 1, 2, 4, 8, ... 2i. En fait D est un nombre binaire, et 2i

*D s'obtient simplement en décalant D de i positions. La balance compare la somme des poids sur chacun de ses deux plateaux ( ≤ ou > ).

Divisions

récurrentes La division est peu fréquente, cependant comme son délai d'exécution est bien plus grand que celui de l'addition ou de la multiplication, son incidence sur le temps de calcul est substantielle. Il convient donc de soigner la réalisation des diviseurs. On veut calculer Q = A ÷ D. Ceci est équivalent à Q * D = A. Donc si Q et D s'écrivent chacun avec n bits, A s'écrit avec 2n bits. On va construire une suite Qn, Qn-1, ... Q2, Q1, Q0 et une suite Rn, Rn-1, ... R2, R1, R0 telles que l'invariant A = Qj * D + Rj soit respecté pour tout j. La récurrence est :

• Qj-1 = Qj + qj-1 × 2j-1 • Rj-1 = Rj – qj-1

× D × 2j-1 avec comme conditions initiales :

• Qn = 0 • Rn = A.

Quand la récurrence se termine, on a Q = Q0 = Σj=0n qj * 2j. R = R0 est le reste de la

division.


Soustracteur conditionnel

Un "soustracteur conditionnel" donne le résultat S suivant: si R < D alors S = R sinon S = R – D ; Chaque cellule "SC" calcule le résultat et la retenue de la soustraction R – D. Si la retenue sortante (tout à gauche) vaut '1' alors S reçoit le résultat de la soustraction, sinon S reçoit R. Cette dernière opération qui rétablit l'ancienne valeur de R est parfois appelée "restauration", d'où le nom du diviseur.

La fonction du "soustracteur conditionnel": si R < D alors S = R sinon S = R – D, se résume par sa fonction de transfert appelée "diagramme de Robertson". Pour converger la division impose en outre que 0 ≤ R ≤ 2*D, ce que montre le diagramme.


Cellule "SC" du soustracteur conditionnel

Vérifiez que vous maîtrisez les fonctions logiques de la cellule "SC" :

si q = '0' alors { co = majorité ( r, –d, ci ) ; s = r } // identité

sinon { co = majorité ( r, –d, ci ) ; s = r ⊕ –d ⊕ ci } // soustraction

Diviseur avec restauration

Un diviseur "avec restauration" consiste en une suite de décalages et de tentative de soustractions. Il est formé d'une structure régulière de cellules de soustraction conditionnelle "SC" (identité ou soustraction selon q j )..

Inverse de la division

Si on retourne le diviseur "avec restauration" tête en bas et replace les soustracteurs conditionnels "SC" par des additionneurs conditionnels "AC" ( identité ou addition selon xi ) on obtient l'opérateur de l'inverse de la division c'est à dire la multiplication avec "reste" : A = D × Q + R .



Diviseur sans restauration

Un diviseur "sans restauration" consiste en une suite de décalages et d'additions ou de soustractions. Il est formé d'une structure régulière de cellules d'addition/soustraction "AS" (addition ou soustraction en fonction de q).

• si R < 0 et D < 0 alors {S = R – D ; q = ' } 1'• si R < 0 et D ≥ 0 alors {S = R + D ; q = '1– '} • si R ≥ 0 et D < 0 alors {S = R + D ; q = '1– '} • si R ≥ 0 et D ≥ 0 alors {S = R – D ; q = '1'}

Le fonctionnement de l'addition/soustraction "AS" est donnée par le de "diagramme

de Robertson" si R < 0 alors S = R + D sinon S = R – D.

Avantage et inconvénient du diviseur

sans

Le diviseur sans restauration a l'avantage de la compatibilité de A et de D avec le complément à 2. Cependant pour que le résultat soit unique on convient que le reste R soit toujours du même signe que le dividende A. Une correction finale est alors nécessaire pour que le diviseur sans restauration obéisse à cette convention. Enfin le


restauration quotient Q est écrit avec les chiffres '1– ' et '1' , il faut donc le convertir en binaire, ce qui est très simple.

Pour la division, on convient que si le reste R n'est pas nul alors il doit avoir le même signe que le dividende A. Un ajustement ultime du quotient Q par +1 ou -1 est parfois nécessaire pour faire obéir le diviseur sans restauration à cette convention.

• si A ≥ 0 et R < 0 et D ≥ 0 alors { Q = Q – 1 ; R = R + D } • si A ≥ 0 et R < 0 et D < 0 alors { Q = Q + 1 ; R = R – D } • si A < 0 et R > 0 et D ≥ 0 alors { Q = Q + 1 ; R = R – D } • si A < 0 et R > 0 et D < 0 alors { Q = Q – 1 ; R = R + D }

Il reste un cas pathologique R = - | D | à détecter et corriger pour obtenir R = 0 .

Diagramme de Robertson

Pour avoir un diagramme de Robertson carré, on normalise les restes successifs: ( Rj × b-j ) où b est la base de numération. Les pentes noires représentent la fonction de transfert Rj ⇒ Rj-1, le trait rouge est la fonction unité qui passe d'une étape à la suivante.

La base 10 nous est familière, elle ne sert ici que comme illustration car elle serait très inefficace codée en binaire.

Diviseurs rapides

Trois approches se combinent pour réaliser des diviseurs rapides: • Utiliser des additions/soustraction sans propagation de retenue. • Préconditionner le diviseur et le dividende pour simplifier la division. • Utiliser des grandes bases pour diminuer le nombre d'étapes.


Division "SRT" sans

propagation de retenue

Pour éviter le délai dû à la propagation de retenue, on utilise ici une suite d'additionneur/soustracteur à emprunt conservé ("BS"). La cellule "tail" , variante de la cellule "SC", exécute suivant les deux bits de commande qui la traversent:

• une addition : Rj-1 = Rj + 2j-1 * D

• une soustraction : Rj-1 = Rj – 2j-1 * D

• une identité : Rj-1 = Rj

Cette opération est choisie suivant le signe du reste Rj. Pour connaître précisément ce

signe il faudrait pouvoir examiner tous les chiffres du reste. On montre qu'il n'est nécessaire d'en examiner que 3. De plus on connaît la position de ces 3 chiffres: celui de droite est aligné avec le premier bit à "1" du diviseur. Pour éviter que cette position ne se déplace avec les valeurs de D, D est "normalisé", c'est à dire que la position de son premier bit à "1" dans le diviseur est fixé. La flèche marquée "vue" à côté du bouton montre les chiffres ou bien les bits ou bien déplace la virgule juste après le premier chiffre de D comme pour les mantisses ou bien après le dernier chiffre de D comme pour les entiers. L'applet permet d'essayer le diviseur avec des entiers pour lesquels D est normalisé entre 2n-1 et 2n–1 ou avec des mantisses pour lesquels D est dans l'intervalle [1, 2 [ .

Additionneur/ Soustracteur

conditionnel sans propagation

Un "additionneur/soustracteur conditionnel" donne l'un des résultats S suivant: • si q = '1' alors S = R – D ; // soustraction • si q = '0' alors S = R ; // identité • si q = '1– ' alors S = R + D ; // addition


Chaque cellule "tail" réalise l'addition/soustraction de 1 bit. La retenue n'est pas

propagée vers la cellule de gauche de la même ligne mais envoyée vers la cellule de la ligne suivante. La fonction de l' "additionneur/soustracteur conditionnel" se résume par sa fonction de transfert appelée "diagramme de Robertson". Pour converger, la division impose en outre que -2*D ≤ R ≤ 2*D. Si -D ≤ R ≤ 2 alors S a deux solutions.

Cellule "tail" du diviseur "SRT"

Vérifiez que vous maîtrisez les fonctions logiques de la cellule "tail" . • si q = '1' alors 2*s1 – s0 = —d0 + r0 ; // soustraction • si q = '0' alors 2*s1 – s0 = r0 ; // identité • si q = '1–' alors 2*s1 – s0 = d0 + r0 ; // addition


Cellule de tête du diviseur "SRT"

Soient R = r2* 4 + r1* 2 + r0 et S = s2* 4 + s1* 2 + s0 les valeurs respectivement des entrées et des sorties de la cellule de tête.

• si R > 0 alors { S = R – 2 ; q = '1' ; }

• si R = 0 alors { S = R ; q = '0' ; }

• si R < 0 alors { S = R + 1 ; q = '1–' ; } Lors d'une division correcte (sans débordement), la sortie s2 est toujours à 0. Cepen-dant le débordement est utilisé dans la "double division" pour le calcul de sinus.

Cellules "head"

et "tail" Une cellule "head" suivie de cellules "tail" exécutent ensemble l'algorithme :

• si R > 0 alors S = R – D ; // soustraction

• si R = 0 alors S = R ;

• si R < 0 alors S = R + D ; // addition

Nécessité du '0' dans l'écriture

de Q

Nécessité de la normalisation du diviseur D

Si R > 0 il ne faut pas faire d'addition et si R < 0 il ne faut pas faire de soustraction sous peine de débordement. Quand = 0, le signe de R n'est pas connu, donc on ne fait ni addition ni soustraction et q = '0' . Pour la cellule "head", un reste est petit si R= 0 , c'est à dire si -1 < R < 1 indépendamment de D. Dans ce cas R conserve sa valeur et sort du "diagramme de Robertson" si 1 > D. En conséquence 1 ≤ D. La borne supérieure de D est destinée à faciliter la réalisation: moins il y a de chiffres de D avant la virgule et moins il y a de chiffres de R a examiner par "head" et plus le circuit est rapide, donc 1 ≤ D < 2 , D est "normalisé"


Division "SRT"

avec réduction du diviseur

La division "SRT" précédente est simple car le premier bit du diviseur D est toujours '1'. Elle se simplifie davantage si les deux premiers bits d0 et d1 du diviseur D sont réduits à "1 0" par l'opération : si d1 alors { D = D * 3/4 ; A = A * 3/4 ; } . Cette multiplication de A et D par la même constante ne modifie pas le quotient Q, par contre le reste R est aussi multiplié. Pour un diviseur sur n bits, 2n-1 – 1 < D < 2n-1 + 2n-2 .

Cellule de tête du

diviseur "SRT" avec réduction

Soient R = r1* 2 + r0 la valeur de l'entrée de la cellule de tête "head". • si R > 1 alors { s0 = R – 3 ; q = '1' ; } • si R = 1 alors { s0 = 0 ; q = - 0 ; } • si R = 0 alors { s0 = 0 ; q = + 0 ; } ou bien { s0 = '1–' ; q = - 0 ; } • si R = -1 alors { s0 = -1 ; q = + 0 ; } • si R < -1 alors { s0 = R + 2 ; q = '1–' ; }

La différence entre les deux écritures de 0 pour q : "- 0" et "+ 0" importe.


Convertisseur

de quotient Le quotient Q du diviseur SRT est en notation redondante. Sa conversion en notation conventionnelle passe par un additionneur (en fait un soustracteur). Comme les chiffres q du quotient sont calculés séquentiellement (poids forts d'abord), la conversion peut être menée en même temps que le calcul des chiffres q. Soit "Ratio" le rapport entre le délai de la cellule de tête du diviseur SRT et le délai de la cellule "BK".

Conception d'un diviseur Les chiffres du quotient Q sont redondants et symétriques. Ils sont définis

par la base de numération de Q et la valeur maximale du chiffre Q. Le choix du nombre de chiffres du diviseur D et du reste partiel P pris en compte détermine si on peut tracer des frontières séparant les chiffres de Q.


Le bouton à gauche passe à l'étape suivante ou revient à l'étape précédente.

1- diagramme de Robertson, donnant le reste partiel suivant en fonction du reste partiel P courant , sans tenir compte explicitement de D 2- PD-plot symétrique tracé pour les valeurs de D dans [ 1/2 , 1 [ 3- demi PD-plot continu, moitié supérieure du précédent. La moitié inférieure s'obtiendrait en changeant les signes. 4- demi PD-plot à discrétiser, le nombre de bits de D fixe le pas en abscisse, le nombre de chiffres de P fixe le pas en ordonnée. Ce choix détermine si on peut tracer des frontières pour séparer les chiffres de Q. 5- demi-table de vérité du demi PD-plot.


Extracteur de racine carrée Extraction de racine carrée

L'extraction de racine carrée est relativement peu fréquente. Cependant elle intervient entre autres dans les distances euclidiennes et dans les moindres carrés. L'opérateur d'extraction s'apparente au diviseur et tout ce que l'on sait de la division rapide s'applique à la racine carrée. Souvent le même opérateur rapide exécute soit la division, soit l'extraction de racine, les collisions étant trop rares pour justifier deux opérateurs par ailleurs coûteux.

Algorithme d'extraction de

racine carrée

Dans le dessin ci-dessous, la surface de chaque rectangle rouge représente le poids de un bit. Seuls les bits à '1' sont dessinés. La surface totale dessinée est donc la somme pondérée de ces bits. Le jeu consiste à trouver un carré de surface égale à un nombre donné, nombre dont la valeur est représentée par la surface d'un cercle bleu, en observant un bit de test ( ≤ ou > ) et en cliquant des bits. Le côté de ce carré est alors la racine cherchée.

Extracteur de racine carrée

On veut calculer Q = A . Ceci est équivalent à Q = A ÷ Q. Donc si Q s'écrit sur n bits, A s'écrit avec 2n bits. On va construire une suite Qn, Qn-1, ... Q2, Q1, Q0 et une suite R2n, R2n-2, ... R4, R2, R0 telles que l'invariant A = Qj * Qj + R2j soit respecté pour tout j. La récurrence est :

• Qj-1 = Qj + qj-1 * 2j-1 • R2j-2 = R2j – qj-1 * 2j-1 * ( 2 * Qj + 2j-1)

avec comme conditions initiales : • Qn = 0 • R2n = A.

Quand la récurrence se termine, on a Q = Q0 = Σj=0n qj * 2j.

R = R0 est le reste de l'extraction de racine. Si on remplace les fausses additions "+" par des concaténations, notées "&", la récurrence devient:


• Qj-1 = Qj & qj-1 • R2j-2 = R2j – qj-1* 2j * ( Qj & 0 1 ) ( soustraction conditionnelle )

Réalisation L'extracteur de racine carrée avec restauration utilise les mêmes soustracteurs

conditionnels "SC" que le diviseur avec restauration.


• si R2j ≥ ( Qj & 0 1 ) alors { qj-1 = '1' ; R2j-2 = R2j – ( Qj & 0 1 ) } //soustraction • si R2j < ( Qj & 0 1 ) alors { qj-1 = '0' ; R2j-2 = R2j } // identité

De nombreuses cellules de ce circuit ont des entrées constantes ( '0' ou '1' ). Elles ne sont pas simplifiées ici comme dans le diviseur avec restauration.

Extracteur sans restauration

L'extracteur de racine carrée sans restauration utilise les mêmes cellules d'addition/soustraction "AS" que le diviseur sans restauration.

• si R2j ≥ 0 alors { qj-1 = ' ; R'1• si R

2j-2 = R2j – ( Qj & 0 1 ) } //soustraction 2j < 0 alors { qj-1 = '1–' ; R2j-2 = R2j + ( Qj & 11 ) } // addition

En fait les valeurs des Qj successifs sont impaires, c'est à dire terminés à droite par un '1' implicite, qui ne sera explicité qu'à la conversion finale. Après quelques distributions de signe :

• si qj-1 = '1' alors R2j-2 = R2j – ( Qj+1 & ( 1 0 0 + 0 0 1 ) ) //soustraction • si qj-1 = '1–' alors R2j-2 = R2j + ( Qj+1 & ( 1 0 0 – 0 0 1 ) ) // addition

Comme la racine Q est positive, son bit pois fort qn vaut toujours '1'. Cet extrateur donne toujours une racine Q impaire. Si le reste final est négatif (bit de signe = 1), alors Q est trop grand et il est facile de le diminuer car il est impair. L'intérêt de ces deux extracteurs est de montrer que l'on peut utiliser des chiffres valant '0', '1' ou '-1' (notation "BS") .


rapide

On cherche à s'affranchir de la propagation de retenue en utilisant la notation "BS", les mêmes cellules "head" et "tail" et une architecture similaire à celle de la division rapide. On se heurte à trois difficultés en cherchant à utiliser ce diviseur pour extraire des racines.


Convertisseur de racine

La première difficulté est le rebouclage de la racine. Comme le diviseur, l'extracteur de racine carrée rapide fourni des racines partielles Qj en notation "BS". Utiliser les mêmes cellules "head" et "tail" que le diviseur rapide exige une racine partielle en notation binaire conventionnelle. On pourrait utiliser un soustracteur pour la conversion de "BS" à binaire de chaque Qj mais ce serait coûteux en temps et en circuit. Le convertisseur ci-dessous utilise une cellule "trc" à 4 entrées et 2 sorties dérivées de la cellule "BK". Pour n entrées, il donne n(n+1)/2 bits à reboucler.

Ce circuit a un autre intérêt : il fourni l'entrée Q (la racine) convertie de "BS" en binaire. Il fourni en plus une sortie Qm = Q0 – 1. Si le reste final R de l'extraction de racine sans propagation de retenue est négatif, c'est que le Q calculé est trop grand (de 1) et Qm est la bonne valeur de la racine. Dans le cas contraire, Q0 donne la valeur de la racine.

Cellule du convertisseur de

racine

Vérifiez que vous maîtrisez les fonctions logiques de la cellule "trc" de conversion de notation "BS" vers notation binaire conventionnelle. L'entrée "si" est un bit du Qj, l'entrée "ci" indique que la retenue se propage à la position de cette cellule. La retenue est utilisée pour la soustraction. Elle correspond au 'P' de la cellule"BK".

• si qj = '1–' alors { so = si ⊕ ci ; co = 0}//soustraction (somme – retenue), retenue tuée

• si qj = '0' alors { so = si ; co = ci } //somme inchangée, retenue propagée • si qj = '1' alors { so = si ; co = 0 } //somme inchangée, retenue tuée



sans propagation de

retenue

L'extracteur rapide utilise les mêmes cellules que le diviseur rapide pour effectuer à chaque itération une des opérations arithmétiques :

• si qj = '1–' alors R2j-2 = R2j + 2j * Qj – 22j-1 // addition

• si qj = '0' alorsR2j-2 = R2j // identité • si qj = '1' alors R2j-2 = R2j – 2j

* Qj – 22j-1 //soustraction La deuxième difficulté par rapport à la division est dans la soustraction de 22j-1

quand qj = '-1' ou qj = '1'. Ce cas est détecté par une porte "ou" dont la sortie est relié à l'entrée négative de la cellule "tail" en poids faible de chaque ligne. Ramené à des entiers, une ligne calcule S = 4 * R + A – qj-1 * ( 4 * Qj + qj-1 ) ou encore S = R & a1 & a0 – qj-1 * ( Qj & 0 & qj-1 ), "&" désignant la concaténation.

Chaque cellule "head" détermine un qj grâce à la valeur d'un approximant R2j du

reste courant R2j limité aux 3 premiers chiffres de R2j.


La deuxième difficulté de l'extraction de racine par rapport à la division est dans la

soustraction de 22j-1 quand qj = '1–' ou qj = '1'. On utilise pour cette soustraction de un bit l'entrée négative de la cellule "tail" en poids faible de chaque ligne. La troisième difficulté limite en fait le domaine d'utilisation. En effet tous les Qj doivent commencer par un '1' en poids fort (implicite). Cette condition n'est pas réalisée si les deux premiers bits du radicande A sont nuls tous les deux. On soustrait ce '1' de A à la première ligne grâce à une entrée négative de "head".

La racine Q sort à gauche en notation "BS" et sort en bas convertie en binaire

conventionnel.

Diviseur et extracteur de racine carrée

Le même circuit peut exécuter soit la division soit l'extraction de racine carrée grâce à des multiplexeurs "2 ⇒ 1" insérés sur les entrées de certaines cellules "tail". La flèche à côté du bouton permute les connexions des entrées d'environ la moitié des cellules "tail" et permute ainsi la fonction réalisée. Pour clarifier le dessin convertisseur n'est pas dessiné pour la division. Il est cependant toujours connecté à Q et fourni en sortie un quotient ou une racine en


binaire conventionnel.

pour l'extraction de racine l'entrée D est déconnectée.

La comparaison de ces deux dessins montre où insérer les multiplexeurs.


Addition en Virgule Flottante Format des nombres en

virgule flottante

Trois champs composent l'écriture binaire des nombres en virgule flottante. Le signe S (1 bit), l'exposant E (8 bits) et la mantisse M, ou significande (23 bits). La valeur du nombre est (-1)S * 2(E - 127) * (1 + M / 8388608 ) . Cependant si E = 0, le nombre dénormalisé vaut (-1)S * 2(-126) * ( M / 8388608 ) et si E = 255, la valeur est infinie. Vérifiez que vous vous maîtrisez ce format en donnant l'écriture (32 bits) des nombres proposés.

Addition et

soustraction Les réels étant codés en "signe/valeur-absolue", un seul bit permet de changer le signe d'un opérande. En conséquence le même opérateur effectue indifféremment l'addition ou la soustraction suivant les signes des opérandes. L'addition/soustraction de deux réels S = A + B est plus complexe que la multiplication ou la division. Elle se déroule en 4 étapes:

• Alignement des mantisses si les exposants de A et B sont différents • Addition ou soustraction des mantisses alignées • Renormalisation de la somme S si elle n'est pas normalisée • Arrondi de la somme S au plus près.

L'alignement produit un bit de garde, un bit d'arrondi et un bit collant utilisés pour l'arrondi au plus près.


Additionneur/

soustracteur Un additionneur flottant est formé des blocs ci-dessous: Bloc1: sort plus grand exposant (8 bits), sort la distance des exposants (5 bits), sort le bit implicite du plus petit opérande et le bit implicite du plus grand opérande.Bloc 2: sort à gauche la mantisse du plus petit opérande (23 bits), sort à droite la mantisse du plus grand opérande (23 bits). Décaleur 1: décale vers la droite la mantisse du plus petit, ajoute un bit de garde et un bit collant; total 26 bits. Complémenteur: fait sur commande le complément logique en vue d'une soustraction. Additionneur 1: additionne les deux entrées et la retenue, sort un résultat arrondi et une retenue. Compteur de zéros en tête: la sortie ZLC compte nombre de '0' en poids forts si le résultat n'est pas normalisé et vaut '1' autrement. Décaleur 2: décale vers la gauche ( ZLC – 1 ). Le bit sortant poids fort est perdu ( '1' implicite). Additionneur 2: soustrait du plus grand exposant ( ZLC – 1 ).

Décaleur rapide Pour l'addition en virgule flottante, il faut effectuer des additions d'entiers, des

décalages paramétrables (à droite pour l'alignement, à gauche pour la renormalisation) et un comptage des zéros en poids forts. Nous savons effectuer l'addition en temps log2(n). Le décalage paramétrable est également en temps log2(n). Un réseau de portes logiques calcule le "bit collant".


Compteur de zéros en tête

( ZLC )

Un arbre binaire décompte le nombre de '0' en poids forts de la chaîne de bits S par dichotomie. Si la taille des sous-chaînes est une puissance de 2, alors il n'y a pas besoin d'additionneur mais seulement de multiplexeurs. En fait seule la taille de la sous-chaîne de gauche doit être une puissance de 2, la taille de la chaîne de droite doit simplement être inférieure ou égale à celle de gauche.

Cellule de

compteur de zéros en tête

Cette cellule combine le nombre de '0' en poids forts de chacune de deux chaînes de longueur 16 pour obtenir le nombre de '0' en poids forts de la concaténation des deux chaînes.

. si X < 16 alors S = X sinon S = 16 + Y


Prédiction de zéros en tête

A partir des mantisses A et B on peut construire une chaîne de bits P ayant (à 1 près) le même nombre de zéros en tête que le résultat de la différence D = A – B sans effectuer la soustraction. En entrée d'un ZLC, cette chaîne prédit le nombre de décalage. Si le résultat du décalage a encore un zéro en tête, il faut décaler ce résultat de une position. Dans le cas contraire, ce résultat est normalisé.

La prédiction est exploitable si A est normalisé et B inférieur ou égal à A, ce qui est le

cas dans une soustraction de mantisses. Alors les zéros en tête viennent de la séquence de retenue 'P'* 'G' 'K'* , formée d'un certain nombre (éventuellement nul) de 'P' suivi de un seul 'G' puis d'un certain nombre de 'K' . Le prédicteur sort un '0' pour toute paire dans cette séquence: 'P' 'P' ; 'P' 'G' ; 'G' 'K' et 'K' 'K' et sort un '1' pour toute paire hors de la séquence. Ce prédicteur ne tient pas compte de la propagation de retenue, d'où une possibilité de bits faussement prédits. Cependant seul le dernier bit dans la séquence 'P'* 'G' 'K'* peut être faussement prédit.


Cellule de prédiction

La cellule de prédiction des zéros en tête génère un '1' à la fin de la chaîne 'P'* 'G' 'K'* et des '0' à l'intérieur de celle-ci.

Ajustement de zéros en tête

Ce circuit rend 'Y' si la prédiction du nombre de zéros en tête est fausse, donc trop petite de 1. La prédiction est fausse si la séquence de retenues commence par 'P'* 'G' 'K'* 'P' 'P'* 'K'. Z indique une chaîne 'K'* 'P'* Q indique une chaîne 'P'* 'G' 'K'* 'P'* (contenant un seul 'G') N indique une chaîne commençant par 'P'* 'K' Y indique une chaîne commençant par 'P'* 'G' 'K'* 'P' 'P'* 'K', c'est à dire Q suivi de N. U marque toute autre chaîne

Valeur absolue de la différence

Le Bloc1 calcule la valeur absolue de la différence des exposants pour commander le Décaleur 1. Le signal "rebouclage" indique A ≥ B qui choisit le plus grand exposant.

Arrondi au plus Dans une addition/soustraction virgule flottante, la sortie S de l'additionneur est


proche normalisée par décalage. Cette sortie S, de 28 bits, est étiquetée "sortie add." dans la figure ci-dessus. Ensuite S est arrondie au plus proche par l'ajout de 0 ou 1 ulp pour donner finalement la mantisse du résultat. Le décalage à gauche de plus de 1 position n'entraîne jamais d'ajout. En pré-décalant la soustraction de une position à gauche on se ramène pour l'arrondi simplement aux cas :

• décalage à droite de 0 ou 1 position (S ou S/2) puis • ajout de 0 ou ulp (avec propagation de retenue) (S ou S/2 ou S + ulp ou S/2 + ulp)

Spéculation de

l'arrondi Pour éviter la propagation de retenue au cours de l'arrondi, on pré-calcule avec un additionneur à 3 sorties en même temps que S les sorties S' = S + 1 et S" = S + 2. Avec le décalage des sorties S et S" le résultat final est S, S/2, S' = S + 1, S"/2 = S/2 + 1.

entity FloatAdd is port ( A, B : in Std_Logic_Vector ( 31 downto 0 ) ; -- A,B: diffend SO : out Std_Logic_Vector (31 downto 0 ) ) ; -- Summ end FloatAdd; architecture TEST of FloatAdd is component AbsDiff is port ( A, B : in Std_Logic_Vector ( 7 downto 0 ) ; -- A, B: diffend D : out Std_Logic_Vector ( 4 downto 0 ) ) ; -- D: Distance end component ; component Compar is port ( A, B : in Std_Logic_Vector ( 30 downto 0 ) ; -- A,B: diffend AeqB : out Std_Logic ; -- A equals B AgtB : out Std_Logic ) ; -- A greater than B end component ; component Decod is port ( D : in Std_Logic_Vector ( 7 downto 0 ) ; -- D S : out Std_Logic_Vector ( 23 downto 0 ) ) ; -- D decoded


end component ; component ShiftR is port ( E : in Std_Logic_Vector (23 downto 0 ) ; -- E : input D : in Std_Logic_Vector (4 downto 0 ) ; -- D : positions Z : out Std_Logic_Vector (23 downto 0 ) ; -- Z : E shifted D positions g : out Std_Logic ; -- g : guard r : out Std_Logic ; -- r : round s : out Std_Logic ) ; -- s : sticky end component ; component ZLPC is port ( A, B : in Std_Logic_Vector (23 downto 0 ) ; -- A : addend, B : subend M : in Std_Logic_Vector (23 downto 0 ) ; -- M : mask o : in Std_Logic ; -- o : inhibit ZLPC if add Z : out Std_Logic_Vector (4 downto 0 ) ; -- Z : number of predicted leading zeroes n : out Std_Logic ) ; -- n : result not normalisable end component ; component compoundadder is port ( A, B : in Std_Logic_Vector (23 downto 0) ; -- A addend, B addend/subend o : in Std_Logic ; -- o : operation 0=>add, 1=>sub g : in Std_Logic ; -- g : guard r : in Std_Logic ; -- r : round s : in Std_Logic ; -- s : sticky S0 : out Std_Logic_Vector (24 downto 0) ) ; end component ; component AddEx is port ( E : in Std_Logic_Vector (7 downto 0 ) ; -- E : addend o : in Std_Logic ; -- o : o : operation 0=>add, 1=>sub u : in Std_Logic ; -- u : error in prediction, this input late Z : in Std_Logic_Vector (4 downto 0 ) ; -- Z : subend, number of leading '0' S : out Std_Logic_Vector (7 downto 0 ) ; -- S : if o then S = E - Z - u + u else S <= E - u l : out std_Logic ) ; -- S : is nul end component ; component ShiftL is port ( E : in Std_Logic_Vector (24 downto 0 ) ; -- E : input to be shifted Z : in Std_Logic_Vector (4 downto 0 ) ; -- D : positions (subtract from exponent) n : in Std_Logic ; -- n : inhibit prediction correction S : out Std_Logic_Vector (23 downto 0 ) ; -- S : E shifted D positions u : out Std_logic ) ; -- u : prediction was false (add 1 to exponent) end component ; signal Am0, Bm0, Am1, Bm1, Bm2 : Std_Logic_Vector (23 downto 0) ; signal Sm0 : Std_Logic_Vector (24 downto 0) ; signal Sm1 : Std_Logic_Vector (23 downto 0) ; signal Sm2 : Std_Logic_Vector (22 downto 0 ) ; signal Mask : Std_Logic_Vector (23 downto 0) ; signal Se0, Se1, SeZ : Std_Logic_Vector (7 downto 0) ; signal D : Std_Logic_Vector (4 downto 0) ; -- distance : abs( Ae - Be) signal Z : Std_Logic_Vector (4 downto 0) ; -- zeros leading, must be subtracted from the exponent signal ha, hb : Std_Logic ; -- hidden bits of A and B ( A or B subnormal) signal o : Std_Logic ; -- operation, 0 : addition, 1 : subtraction signal v : Std_Logic ; -- abs(A) and abs(B) are equal signal w : Std_Logic ; -- A and B must be swapped around signal g : Std_Logic ; -- guard bit from alignment signal r : Std_Logic ; -- round bit from alignment signal s : Std_Logic ; -- sticky bit from alignment signal u : Std_Logic ; -- extra shift, must be added to the exponent signal n : Std_Logic ; -- inhibit correction signal l : Std_Logic ; -- Sm1 = 0 (S0 subnormal)


begin -- step 1 ha <= A(30) or A(29) or A(28) or A(27) or A(26) or A(25) or A(24) or A(23) ; -- reveal A's hidden bit hb <= B(30) or B(29) or B(28) or B(27) or B(26) or B(25) or B(24) or B(23) ; -- reveal B's hidden bit with ha select Am0 <= '1' & A(22 downto 0) when '1' , A(22 downto 0) & '0' when others ; with hb select Bm0 <= '1' & B(22 downto 0) when '1' , B(22 downto 0) & '0' when others ; distance : AbsDiff port map (A(30 downto 23), B(30 downto 23), D ) ; -- exponents distance sort : Compar port map (A(30 downto 0), B(30 downto 0), v, w) ; -- comparison SeZ <= not ( (o and v) & (o and v) & (o and v) & (o and v) & "0000" ) ; with w select Se0 <= A(30 downto 23) when '1', B(30 downto 23) and SeZ when others ; -- larger exponent with w select Bm1 <= Bm0 when '1', Am0 when others ; -- smaller's mantissa with w select Am1 <= Am0 when '1', Bm0 when others ; -- larger's mantissa o <= A(31) xor B(31) ; -- 0 => addition, 1 => subtraction -- step 2 alignment : ShiftR port map (Bm1, D, Bm2, g, r, s) ; -- mantissas alignment maskgen : Decod port map (Se0, Mask) ; -- step 3 count_0 : ZLPC port map (Am1 , Bm2, Mask, o, Z, n) ; -- prediction of the leading-one position add_mant : compoundadder port map (Am1, Bm2, o, g, r, s, Sm0) ; -- step 4 normalise : ShiftL port map (Sm0, Z, n, Sm1, u) ; -- mantissa normalisation adjustExp : AddEx port map (Se0, o, u, Z, Se1, l) ; -- exponent adjust, u is late with l select Sm2 <= Sm1(22 downto 0) when '0', Sm1(23 downto 1) when others ; SO <= ((A(31) and w) or (B(31) and not w)) & Se1 & Sm2(22 downto 0) ; end TEST;

Premier pas (Step 1)

Le bloc "AbsDiff" La sortie D (5 bits) du bloc "AbsDiff" est la valeur absolue de la différence des exposants A(30,23) et B(30,23) respectivement de A et de B, saturée à 31. Afin d'être rapide, le calcul de la retenue est "Kogge et Stone". entity AbsDiff is port ( A, B : in Std_Logic_Vector ( 7 downto 0 ) ; -- A,B: addends D : out Std_Logic_Vector ( 4 downto 0 ) ) ; -- D: Distance end AbsDiff ; architecture structural of AbsDiff is signal P0, G0, K0, G1, K1, G2, K2, G3, K3, S : Std_Logic_Vector ( 7 downto 0 ) ; -- prop, gen, not kill begin -- row 0 G0 <= A and not B ; -- generate K0 <= A or not B ; -- spare (not kill) P0 <= not G0 and K0 ; -- propagate -- "BK" cells row 1 (distance 1) G1 <= (K0(7 downto 1) and ( G0(7 downto 1) or G0(6 downto 0))) & G0(0) ; K1 <= (K0(7 downto 1) and ( G0(7 downto 1) or K0(6 downto 0))) & K0(0) ; -- "BK" cells row 2 (distance 2) G2 <= (K1(7 downto 2) and ( G1(7 downto 2) or G1(5 downto 0))) & G1(1 downto 0) ; K2 <= (K1(7 downto 2) and ( G1(7 downto 2) or K1(5 downto 0))) & K1(1 downto 0) ; -- "BK" cells row 3 (distance 4) G3 <= (K2(7 downto 4) and ( G2(7 downto 4) or G2(3 downto 0))) & G2(3 downto 0) ; K3 <= (K2(7 downto 4) and ( G2(7 downto 4) or K2(3 downto 0))) & K2(3 downto 0) ; -- feed-back row with K3(7) select S <= P0 xor (not G3(6 downto 0) & '1') when '0', P0 xor (K3(6 downto 0) & '1') when others ; -- reduction from 8 bits downto 5 bits with saturation with S(7) or S(6) or S(5) select D <= S(4 downto 0) when '0', "11111" when others ; end structural


Le bloc "Compar" En parallèle avec le bloc "AbsDif", le bloc "Compar" compare les valeurs absolues (le signe est ignoré) de A et B en calculant la retenue sortante c31 de la soustraction. entity Compar is port ( A, B : in Std_Logic_Vector ( 30 downto 0 ) ; -- A,B: addends C31 : out Std_Logic ) ; -- A greater than B end Compar ; architecture structural of Compar is signal G, P : Std_Logic_Vector (59 downto 0) ; begin -- "HA" cells row G(30 downto 0) <= A and not B ; -- generate P(30 downto 0) <= A xor not B ; -- propagate -- "BK" cells row 1 (distance 1) G(45) <= G(29) or (P(29) and G(28)) ; P(45) <= P(29) and P(28) ; G(44) <= G(27) or (P(27) and G(26)) ; P(44) <= P(27) and P(26) ; G(43) <= G(25) or (P(25) and G(24)) ; P(43) <= P(25) and P(24) ; G(42) <= G(23) or (P(23) and G(22)) ; P(42) <= P(23) and P(22) ; G(41) <= G(21) or (P(21) and G(20)) ; P(41) <= P(21) and P(20) ; G(40) <= G(19) or (P(19) and G(18)) ; P(40) <= P(19) and P(18) ; G(39) <= G(17) or (P(17) and G(16)) ; P(39) <= P(17) and P(16) ; G(38) <= G(15) or (P(15) and G(14)) ; P(38) <= P(15) and P(14) ; G(37) <= G(13) or (P(13) and G(12)) ; P(37) <= P(13) and P(12) ; G(36) <= G(11) or (P(11) and G(10)) ; P(36) <= P(11) and P(10) ; G(35) <= G(9) or (P(9) and G(8)) ; P(35) <= P(9) and P(8) ; G(34) <= G(7) or (P(7) and G(6)) ; P(34) <= P(7) and P(6) ; G(33) <= G(5) or (P(5) and G(4)) ; P(33) <= P(5) and P(4) ; G(32) <= G(3) or (P(3) and G(2)) ; P(32) <= P(3) and P(2) ; G(31) <= G(1) or (P(1) and G(0)) ; -- "BK" cells row 2 (distance 2) G(53) <= G(30) or (P(30) and G(45)) ; P(53) <= P(30) and P(45) ; G(52) <= G(44) or (P(44) and G(43)) ; P(52) <= P(44) and P(43) ; G(51) <= G(42) or (P(42) and G(41)) ; P(51) <= P(42) and P(41) ; G(50) <= G(40) or (P(40) and G(39)) ; P(50) <= P(40) and P(39) ; G(49) <= G(38) or (P(38) and G(37)) ; P(49) <= P(38) and P(37) ; G(48) <= G(36) or (P(36) and G(35)) ; P(48) <= P(36) and P(35) ; G(47) <= G(34) or (P(34) and G(33)) ; P(47) <= P(34) and P(33) ; G(46) <= G(32) or (P(32) and G(31)) ; -- "BK" cells row 3 (distance 4) G(57) <= G(53) or (P(53) and G(52)) ; P(57) <= P(53) and P(52) ; G(56) <= G(51) or (P(51) and G(50)) ; P(56) <= P(51) and P(50) ; G(55) <= G(49) or (P(49) and G(48)) ; P(55) <= P(49) and P(48) ; G(54) <= G(47) or (P(47) and G(46)) ; -- "BK" cells row 4 (distance 8) G(59) <= G(57) or (P(57) and G(56)) ; P(59) <= P(57) and P(56) ; G(58) <= G(55) or (P(55) and G(54)) ; -- "BK" cells row 5 (distance 16) C31 <= G(59) or (P(59) and G(58)) ; end structural;

Deuxième pas (Step 2)

Le bloc "Decod" Le bloc "Decod" transcode la valeur de Se0 (8 bits) en "code thermométrique" (24 bits). La sortie Mask a autant de '0' à gauche que la valeur de Se0, les autres bits sont à '1'. entity Decod is port ( D : in Std_Logic_Vector ( 7 downto 0 ) ; -- D


Mask : out Std_Logic_Vector ( 23 downto 0 ) ) ; -- D decoded end Decod; architecture structural of Decod is signal P : Std_Logic_Vector (53 downto 0) ; begin with D(7) or D(6) or D(5) select Mask <= "000000000000000000000000" when '1', P(23 downto 0) when others ; with D(4) select P(23 downto 0) <= "00000000" & P(39 downto 24) when '1' , P(39 downto 24) & "11111111" when others ; with D(3) select P(39 downto 24) <= "00000000" & P(47 downto 40) when '1' , P(47 downto 40) & "11111111" when others ; with D(2) select P(47 downto 40) <= "0000" & P(51 downto 48) when '1' , P(51 downto 48) & "1111" when others ; with D(1) select P(51 downto 48) <= "00" & P(53 downto 52) when '1' , P(53 downto 52) & "11" when others ; P(53 downto 52) <= not D(0) & '1' ; end ; Le bloc "ShiftR" Le bloc "ShiftR" décale Bm1 à droite de D positions pour donner Bm2. Ce bloc calcule en parallèle les bits g, r et s. entity ShiftR is port ( E : in Std_Logic_Vector (23 downto 0 ) ; -- E : input D : in Std_Logic_Vector (4 downto 0 ) ; -- D : positions Z : out Std_Logic_Vector (23 downto 0 ) ; -- Z : E shifted right D positions g, r, s : out Std_Logic ; -- g : guard, r : round, s : sticky end ShiftR ; architecture structural of ShiftR is signal sticky : Std_Logic ; signal P0, P1, P2, P3, P4, P5 : Std_Logic_Vector (25 downto 0) ; -- internal signals begin P5 <= E & "00" ; -- append room for guard and round bits with D(4) select P4 <= P5 when '0' , "0000000000000000" & P5(25 downto 16) when others ; with D(3) select P3 <= P4 when '0' , "00000000" & P4(25 downto 8 ) when others ; with D(2) select P2 <= P3 when '0' , "0000" & P3(25 downto 4) when others ; with D(1) select P1 <= P2 when '0' , "00" & P2(25 downto 2) when others ; with D(0) select P0 <= P1 when '0' , "0" & P1(25 downto 1) when others ; sticky <= ((P5(15) or P5(14) or P5(13) or P5(12) or P5(11) or P5(10) or P5(9) or P5(8) or P5(7) or P5(6) or P5(5) or P5(4) or P5(3) or P5(2) or P5(1) or P5(0)) and D(4)) or ((P4(7) or P4(6) or P4(5) or P4(4) or P4(3) or P4(2) or P4(1) or P4(0)) and D(3)) or ((P3(3) or P3(2) or P3(1) or P3(0)) and D(2)) or ((P2(1) or P2(0)) and D(1)) or (P1(0) and D(0)) ; Z <= P0(25 downto 2) ; g <= P0(1) ; r <= P0(0) ; s <= sticky ; end structural ;

Troisième pas (Step 3)

Le bloc "ZLPC" Le bloc "ZLPC" compte le nombre de '0' en tête d'une prédiction du résultat de la soustraction Bm2 – Am2 (o = '1') limité à Mask. En parallèle on regarde si le nombre de '0' est inférieur ou égal à Mask (Se0 traduit en code thermométrique), dans ce cas le résultat est normalisable. entity ZLPC is port ( A, B : in Std_Logic_Vector (23 downto 0 ) ; -- A addend, B subtraend Mask : in Std_Logic_Vector (23 downto 0 ) ; -- Se0 leading zeroes o : in Std_Logic ; -- enable if subtraction, disable if addition Z : out Std_Logic_Vector (4 downto 0 ) ; -- Z : number of leading zeroes


n : out Std_Logic ) ; -- N normalised end ZLPC ; architecture structural of ZLPC is signal P : Std_Logic_Vector (93 downto 0) ; -- internal signals signal Q, R : Std_Logic_Vector (23 downto 0 ) ; begin Q <= (A xor B) and ((A(22 downto 0) or not B(22 downto 0)) & '1') ; -- prediction R <= not Q or Mask ; n <= R(23) and R(22) and R(21) and R(20) and R(19) and R(18) and R(17) and R(16) and R(15) and R(14) and R(13) and R(12) and R(11) and R(10) and R(9) and R(8) and R(7) and R(6) and R(5) and R(4) and R(3) and R(2) and R(1) and R(0) ; P(93 downto 70) <= not (Q or Mask) ; -- counter row 1 (blocks of 2) P(69 downto 68) <= (P(93) and P(92)) & (P(93) and not P(92)) ; P(67 downto 66) <= (P(91) and P(90)) & (P(91) and not P(90)) ; P(65 downto 64) <= (P(89) and P(88)) & (P(89) and not P(88)) ; P(63 downto 62) <= (P(87) and P(86)) & (P(87) and not P(86)) ; P(61 downto 60) <= (P(85) and P(84)) & (P(85) and not P(84)) ; P(59 downto 58) <= (P(83) and P(82)) & (P(83) and not P(82)) ; P(57 downto 56) <= (P(81) and P(80)) & (P(81) and not P(80)) ; P(55 downto 54) <= (P(79) and P(78)) & (P(79) and not P(78)) ; P(53 downto 52) <= (P(77) and P(76)) & (P(77) and not P(76)) ; P(51 downto 50) <= (P(75) and P(74)) & (P(75) and not P(74)) ; P(49 downto 48) <= (P(73) and P(72)) & (P(73) and not P(72)) ; P(47 downto 46) <= (P(71) and P(70)) & (P(71) and not P(70)) ; -- counter row 2 (blocks of 4) P(45 downto 43) <= (P(69) and P(67)) & (P(69) and not P(67)) & (P(68) or (P(69) and P(66))) ; P(42 downto 40) <= (P(65) and P(63)) & (P(65) and not P(63)) & (P(64) or (P(65) and P(62))) ; P(39 downto 37) <= (P(61) and P(59)) & (P(61) and not P(59)) & (P(60) or (P(61) and P(58))) ; P(36 downto 34) <= (P(57) and P(55)) & (P(57) and not P(55)) & (P(56) or (P(57) and P(54))) ; P(33 downto 31) <= (P(53) and P(51)) & (P(53) and not P(51)) & (P(52) or (P(53) and P(50))) ; P(30 downto 28) <= (P(49) and P(47)) & (P(49) and not P(47)) & (P(48) or (P(49) and P(46))) ; -- counter row 3 (blocks of 8) P(27 downto 24) <= (P(45) and P(42)) & (P(45) and not P(42)) & (P(44) or (P(45) and P(41))) & (P(43) or (P(45) and P(40))) ; P(23 downto 20) <= (P(39) and P(36)) & (P(39) and not P(36)) & (P(38) or (P(39) and P(35))) & (P(37) or (P(39) and P(34))) ; P(19 downto 16) <= (P(33) and P(30)) & (P(33) and not P(30)) & (P(32) or (P(33) and P(29))) & (P(31) or (P(33) and P(28))) ; -- counter row 4 (blocks of 16) P(14 downto 11) <= (P(27) and not P(23)) & (P(26) or (P(27) and P(22))) & (P(25) or (P(27) and P(21))) & (P(24) or (P(27) and P(20))) ; -- counter row 5 P(4) <= P(27) and P(23) ; P(3) <= P(14) or (P(4) and P(19)) ; P(2) <= P(13) or (P(4) and P(18)) ; P(1) <= P(12) or (P(4) and P(17)) ; P(0) <= P(11) or (P(4) and P(16)) ; with o select Z <= "00000" when '0' , P(4 downto 0) when others ; end structural; Le bloc "CompoundAdder" Le bloc "CompoundAdder" calcule le résultat correctement arrondi au plus près mais non encore normalisé. Afin d'être rapide, le calcul de la retenue est "Kogge et Stone". entity compoundadder is port ( A, B : in Std_Logic_Vector (23 downto 0) ; o, g, r, s : in Std_Logic ; -- operation, guard, round, sticky S0 : out Std_Logic_Vector (24 downto 0) ) ; -- rounded, not normalised end compoundadder ; architecture structural of compoundadder is signal c, m, k, i, plus1, minus0 : Std_Logic ; signal G0, P0, K0, G1, K1, G2, K2, G3, K3, G4, K4, G5, K5 : Std_Logic_Vector (23 downto 0) ; signal S1, S2 : Std_Logic_Vector (24 downto 0) ; begin with o select G0 <= A and B when '0' , A and not B when others ; -- generate with o select K0 <= A or B when '0' , A or not B when others ; -- spare (not kill)


P0 <= not G0 and K0 ; -- propagate k <= P0(1) xor G0(0) ; -- penultimate i <= P0(0) ; -- least significant -- "BK" cells row 1 (distance 1) G1 <= (K0(23 downto 1) and ( G0(23 downto 1) or G0(22 downto 0))) & G0(0) ; K1 <= (K0(23 downto 1) and ( G0(23 downto 1) or K0(22 downto 0))) & K0(0) ; -- "BK" cells row 2 (distance 2) G2 <= (K1(23 downto 2) and ( G1(23 downto 2) or G1(21 downto 0))) & G1(1 downto 0) ; K2 <= (K1(23 downto 2) and ( G1(23 downto 2) or K1(21 downto 0))) & K1(1 downto 0) ; -- "BK" cells row 3 (distance 4) G3 <= (K2(23 downto 4) and ( G2(23 downto 4) or G2(19 downto 0))) & G2(3 downto 0) ; K3 <= (K2(23 downto 4) and ( G2(23 downto 4) or K2(19 downto 0))) & K2(3 downto 0) ; -- "BK" cells row 4 (distance 8) G4 <= (K3(23 downto 8) and ( G3(23 downto 8) or G3(15 downto 0))) & G3(7 downto 0) ; K4 <= (K3(23 downto 8) and ( G3(23 downto 8) or K3(15 downto 0))) & K3(7 downto 0) ; -- "BK" cells row 5 (distance 16) G5 <= (K4(23 downto 16) and ( G4(23 downto 16) or G4(7 downto 0))) & G4(15 downto 0) ; K5 <= (K4(23 downto 16) and ( G4(23 downto 16) or K4(7 downto 0))) & K4(15 downto 0) ; c <= G5(23) ; -- carry m <= P0(23) xor G5(22) ; -- most significant with c select plus1 <= i and ( k or g or r or s ) when '1' , g and ( i or r or s ) when others ; with m select minus0 <= g and ( not i or r or s ) when '1' , g or ( r and s ) when others ; with plus1 select S1 <= ('0' & P0) xor (G5 & '0') when '0', ('0' & P0) xor (K5 & '1') when others ; with minus0 select S2 <= ('1' & P0) xor (G5 & '0') when '1', ('1' & P0) xor (K5 & '1') when others ; with o select S0 <= S1 when '0', S2(23 downto 0) & g when others ; -- pre-shift end structural ;

Quatrième pas (Step 4)

Le bloc "AddEx" Le bloc "AddEx" calcule l'exposant du résultat. En parallèle on regarde si cet exposant est nul, ce qui implique que résultat final est non normalisé et qu'il ne faut pas en effacer le bit pois fort. entity AddEx is port ( E : in Std_Logic_Vector (7 downto 0 ) ; -- E : positive input o : in Std_Logic ; -- o : operation 0=>add, 1=>sub u : in Std_Logic ; -- u : error in prediction, u is late Z : in Std_Logic_Vector (4 downto 0 ) ; -- Z : number of leading '0' S : out Std_Logic_Vector (7 downto 0 ) ; -- S : if o then S = E - Z - u else S <= E - u l : out std_Logic ) ; -- S is nul end AddEx ; architecture structural of AddEx is signal G0, P0, K0, G1, K1, G2, K2, G3, K3 : Std_Logic_Vector ( 7 downto 0 ) ; -- prop, gen, spare signal L0 : Std_Logic_Vector ( 6 downto 0 ) ; begin -- row 0 with o select G0 <= "00000000" when '0', E(7 downto 5) & (E(4 downto 0) and not Z) when others ; with o select K0 <= E when '0' , "111" & (E(4 downto 0) or not Z) when others ; P0 <= not G0 and K0 ; L0 <= not P0(7 downto 1) xor K0(6 downto 0) ; -- "111111" => S = 0 -- "BK" cells row 1 (distance 1) G1 <= (K0(7 downto 1) and ( G0(7 downto 1) or G0(6 downto 0))) & G0(0) ; K1 <= (K0(7 downto 1) and ( G0(7 downto 1) or K0(6 downto 0))) & K0(0) ; -- "BK" cells row 2 (distance 2) G2 <= (K1(7 downto 2) and ( G1(7 downto 2) or G1(5 downto 0))) & G1(1 downto 0) ; K2 <= (K1(7 downto 2) and ( G1(7 downto 2) or K1(5 downto 0))) & K1(1 downto 0) ; -- "BK" cells row 3 (distance 4) G3 <= (K2(7 downto 4) and ( G2(7 downto 4) or G2(3 downto 0))) & G2(3 downto 0) ; K3 <= (K2(7 downto 4) and ( G2(7 downto 4) or K2(3 downto 0))) & K2(3 downto 0) ; -- last row with u select S <= P0 xor (G3(6 downto 0) & '0') when '1', P0 xor (K3(6 downto 0) & '1') when others ; with u select l <= L0(5) and L0(4) and L0(3) and L0(2) and L0(1) and L0(0) and not P0(0) when '1' ,


not G3(7) and K3(7) when others ; end structural ; Le bloc "ShiftL" En parallèle avec "AddEx" le bloc "ShiftL" décale Sm0 à droite de Z positions. Le résultat n'est pas obligatoirement normalisé car il peut y avoir une erreur de prédiction (soustraction) ou un débordement (addition). Le denier étage corrige ces erreurs. entity ShiftL is port ( E : in Std_Logic_Vector (24 downto 0 ) ; -- E : input Z : in Std_Logic_Vector (4 downto 0 ) ; -- Z : positions n : in Std_Logic ; -- n : inhibit correction S : out Std_Logic_Vector (23 downto 0 ) ; -- S : E shifted left Z + u positions u : out Std_Logic ) ; -- add to exponent end ShiftL ; architecture structural of ShiftL is signal P0, P1, P2, P3, P4 : Std_Logic_Vector (24 downto 0) ; -- internal signals begin with Z(4) select P4 <= E when '0' , E(8 downto 0) & "0000000000000000" when others ; with Z(3) select P3 <= P4 when '0' , P4(16 downto 0) & "00000000" when others ; with Z(2) select P2 <= P3 when '0' , P3(20 downto 0) & "0000" when others ; with Z(1) select P1 <= P2 when '0' , P2(22 downto 0) & "00" when others ; with Z(0) select P0 <= P1 when '0' , P1(23 downto 0) & "0" when others ; with P0(24) or n select S <= P0(24 downto 1) when '1' , P0(23 downto 0) when others ; u <= not ( P0(24) or n ) ; end structural ;


Fonctions élémentaires Fonctions

élémentaires On réalise les fonctions Exponentielle, Logarithme, Sinus, Cosinus et Arc tangente avec des additions/soustractions et des décalages fixes. Le décalage fixe est de coût et délai nul si l'opérateur est câblé. Les additions/soustractions sont sans propagation de retenue, donc à délai constant.

coût délai max

addition/soustraction/décalage n2 n

lecture en table (ROM) n * 2n log2(n)

Une lecture en table (ROM) serait plus rapide, mais la taille de la table, donc le coût, croît exponentiellement avec le nombre de bits de précision requis. Toutefois le partitionnement de la table en réduit la taille.

De la pesée du

pain à l'exponentielle

Supposons qu'on veuille calculer X = exp ( Y ). On dispose d'une balance, d'un pain dont le poids est justement Y et enfin d'une série de poids de valeur log(1 + 2-j ). La pesée est classique, la somme des poids demande (Nb. poids – 1) addition. Cependant la valeur des poids est choisie pour que l'exponentielle de la somme des poids s'obtienne également avec (Nb. poids) additions. En effet la valeur de l'exponentielle est un produit de rationnels (2j + 1) / 2j . La multiplication par chacun de ces rationnels se réduit à un décalage et une addition.

Division sans

propagation pour l'exponentielle

On remplace la balance par un diviseur "SRT" dont voici le "diagramme de Robertson".


Diviseur "SRT"

pour l'exponentielle

Le dividende Y (en haut) est dans l'intervalle ] -1 , +1 [ Les constantes log(1 + 2-j ) et -log(1 – 2-j ) entrant dans les cellules "tail" sont câblées. Il y a donc 4 variantes de la cellule "tail" fonction des valeurs de 2 bits.

Opération d'une

tranche de diviseur "SRT"

pour l'exponentielle

Chaque qj est choisi par une cellule "head" en fonction de Rj , somme pondérée des 2 chiffres poids forts r1 et r0 de l'écriture de Rj.

• si Rj > 0 alors { qj = '1' ; s0 = Rj – 2 ; Rj+1 = Rj + log(1 – 2-j ) } // soustraction

• si Rj = 0 ou Rj = -1 alors { qj = '0' ; s0 = Rj ; Rj+1 = Rj + 0 } // identité

• si Rj < -1 alors { qj = '1–' ; s0 = Rj + 2 ; Rj+1 = Rj + log(1 + 2-j ) } //addition


Suite de

multiplications La suite de multiplications conditionnelles par 1, par (1 + 2-j ) ou par (1 – 2-j ) nécessite une seule propagation de retenue finale grâce à des additionneurs en "CS" et des décalages câblés. Les additions en "CS" sont tronquées à 2 n chiffres, dont 2 avant la virgule. Le troisième chiffre poids fort ( tout à gauche ) est le signe. Bien que les résultats partiels soient tous positifs ou nuls, exécuter des soustractions en "CS" entraîne un signe qui doit être étendu lors du décalage. Le résultat final (en bas) doit être traduit de "CS" en binaire par une addition (avec propagation). La fenêtre du bas permet de comparer le produit "vraie" des multiplications (sans troncature) au produit avec troncature.

Exemple

numérique d'exponentielle

Les tableaux ci-dessous montrent les restes partiels du diviseur "SRT" ("BS") puis les produits partiels ("CS") pour le calcul d'exponentielle. La fenêtre du bas permet de comparer la valeur "vraie" de l'exponentielle au produit de multiplications tronquées par (1 + 2-j ) ou par (1 – 2-j ).


On a entré Y = 0,7 dans le diviseur, en fait 0.101100110011001100110011011sur 28 bits (0.6999999843). Le quotient sur 28 chiffres s'écrit 100011-1-01-1-001-1-01-01-001-1-00011-1- et donnerait 2,0137522695814808. En ne gardant que 18 chiffres 100011-1-01-1-001-1-01-01- on obtient finalement X= 2,01375556178391 dont le logarithme vaut environ 0,70000141740909895


Extension du domaine

Le circuit précédent fonctionne pour Y dans l'intervalle ] -1 , +1 [ . Pour l'exponentielle d'un nombre Y quelconque, on écrit Y = Q*log(8) + R, où Q est le quotient entier de la division de Y par log(8) et R < log(8) < 1. Alors exp(Y) = 8Q * exp(R) = 23Q * exp(R). Comme exp(R) < 1, il est calculable par le circuit précédent.

Logarithme et exponentielle

Opérateur de calcul de Logarithme ou d'Exponentielle (c'est le même) avec des additions/soustraction (c'est la même opération), des décalages et des constantes. Les

constantes sont log(1 + 2-j ) et -log(1 – 2-j ) et les chiffres ∈{ '1–' , '0' , '1' }. Cette liberté dans le choix des chiffres, qui fera défaut pour Sinus et Cosinus, permet éventuellement de calculer plus vite avec des additions/soustractions sans propagation


De la pesée du

pain au sinus et au cosinus

On veut calculer sin ( A ) et/ou cos ( A ). On dispose d'une balance, d'un pain dont le poids est justement A et enfin d'une série de poids de valeur ArcTangente( 2-j ). Les poids ne peuvent être que sur l'un ou l'autre des deux plateaux.

Calcul de Sinus Soit un vecteur Vj d'extrémité (Xj, Yj ). Une "pseudoRotation" de Vj d'un angle arctg


et Cosinus (2-j) donne Vj+1 d'extrémité Xj+1 = Xj – Yj * 2-j et Yj+1 = Yj + Xj * 2-j. En décomposant un angle A en une somme pondérée d'arctg (2-j ), une suite de "pseudoRotations" calcule les coordonnées du vecteur d'angle A qui sont les valeurs sin(A) et cos(A) cherchées. Pour chaque "pseudoRotations" on n'a effectué une addition et une soustraction.

La constante k Chaque "pseudoRotation" de arctg(2-j ) entraîne un allongement du vecteur de 1+2-2j

, car ce n'est pas exactement une rotation mais un déplacement de l'extrémité du vecteur sur un vecteur perpendiculaire. Pour compenser par avance le produit des allongements d'une suite de "pseudoRotations", le vecteur de départ est ( X0 = k , Y0 = 0 ) . Pour n assez grand, k vaut environ 0,60725. Pour que k soit une constante, l'écriture dans la

base arctg(2-j ) utilise des chiffres ∈{ '1–', '1' } .

Décomposition d'un angle

Quel est le domaine des angles A = Σj=0n aj * arctg (2-j) et quelle précision espérer de

cette écriture ? L'angle A est la valeur cherchée et l'angle T la valeur atteinte par la suite de "pseudoRotations". Cliquer dans la figure pour changer A. Les valeurs sont en radian. La touche "Mise à zéro" laisse effectuer 'à la main' la conversion de A dans la base arctg (2-j).


"Diagramme de

Robertson" pour sinus et

cosinus

Le "diagramme de Robertson" montre que l'itération de conversion de l'angle dans la base arctg(2-j ) peut être choisie comme suit:

si R ≥ 0 alors { S = R – arctg(2-j ) ; aj = '1' } sinon { S = R + arctg(2-j ) ; aj = '1–' }.

Diviseur "sans restauration" de

sinus et cosinus

L'angle A (en haut du diviseur) est dans l'intervalle [ -1,743.. +1,743...]. Les bits constants entrant dans les cellules "AS" sont câblés. Les opérations sont choisies par le signe des restes partiels R précédent et par y0 pour la première opération .


Opérateur de "PseudoRotation"

pour sinus et cosinus

Si les "PseudoRotations" utilisent des additions/soustractions sans retenue (ici en "CS") alors le délai est linéaire avec le nombre d'étages. Le premier étage n'effectue pas vraiment une addition, puisque X0 = k , Y0 = 0. si a0 = '1' alors { X1 = k ; Y1 = - k } sinon { X1 = k ; Y1 = k }. Pour les étages suivants ( j > 0) si aj = '0' alors { Xj+1 = Xj – Yj * 2-j ;Yj+1 = Yj + Xj * 2-j }

si aj = '1–' alors { Xj+1 = Xj + Yj * 2-j ; Yj+1 = Yj – Xj * 2-j }. Pour simplifier le dessin, la nappe X * 2-j n'y figure pas toujours complètement.


Cellule "RO"

La cellule "RO" est une variante de la cellule d'addition "CS" avec en plus une entrée "a/s" pour contrôler l'addition ou bien la soustraction. Observer que l'activité de la retenue entrante "ci" ne se propage pas vers la flèche du haut de la sortie "co".

• si a/s = '0' alors 2 * co + s = eg + ed + ci // addition • si a/s = '1' alors 2 * co + s = eg + 2 – ed + ci // soustraction


"Diagramme de Robertson"

pour CORDIC à "double

rotation"

On utilise une approximation R du reste R pour déterminer la rotation:

si R > 0 alors aj = '1' ; si R = 0 alors aj = '0' ; si R < 0 alors aj = '1–' ; On constate sur le diagramme que l'approximation peut être grossière.

CORDIC à

"double rotation"

Ce diviseur a les mêmes cellules "head" et "tail" que le diviseur "SRT". Pour s'accommoder du '0', l'angle A est préalablement divisé par 2 et les "pseudoRotations" sont doublées. Grâce à cela l'allongement reste le même

( j41+ )2 quelque soit aj. • si aj = '1–' alors { rotation de (arctg(2-j )) puis rotation de (arctg(2-j )) } ; • si aj = '0' alors { rotation de (arctg(2-j )) puis rotation de (-arctg(2-j )) } ; • si aj = '1' alors { rotation de (-arctg(2-j )) puis rotation de (-arctg(2-j )) } ;


La "double rotation" est coûteuse: elle double le matériel de la rotation et proba-

blement le délai. En regroupant les lignes par deux elle se réécrit : si aj = '1–'alors {Xj+1 = Xj + 2 * Yj * 2-j – Xj * 2-2j; Yj+1 = Yj – 2 * Xj * 2-j – Yj * 2-2j} si aj = '0' alors {Xj+1 = Xj + Xj * 2-2j; Yj+1 = Yj + si aj = '1' alors {Xj+1 = Xj – 2 * Yj * 2-j – Xj * 2-2j; Yj+1 = Yj + 2 * Xj * 2-j – Yj * 2-2j}

Yj * 2-2j }

Cette réécriture ne change pas le nombre d'addition/soustraction sauf lorsque les termes multiples de 2-2j deviennent négligeables. Peut on obtenir un résultat écrit avec des chiffres aj ∈{ '1', '1–' } (sans le '0' ) avec un délai comparable à celui du diviseur pour la double rotation? La conversion du quotient qui marche avec les poids 2-j ( '0' '1' = '1' '1–' ) ne marche plus avec les poids arctg(2-j ) .

CORDIC à "double

division"

La "double division" est plus astucieuse que la conversion. Elle utilise deux divi-seurs fonctionnant simultanément avec des cellules "head" légèrement modifiées. "head" de diviseur1

si R > 0 alors { S = R – 2 ; aj = '1' ; }

si R ≤ 0 alors { S = R +1 ; aj = '1–' ; }

"head" de diviseur2

si R ≥ 0 alors { S = R – 2 ; aj = '1' ; }

si R < 0 alors { S = R +1 ; aj = '1–' ; } Il est clair que lorsque R= 0, diviseur1 parie que R ≤ 0 et diviseur2 que R ≥ 0. L'un des deux au plus se trompe et en conséquence peut déborder, avant ou en même temps que l'apparition du R = 0 suivant. Au débordement on saura que le résultat correct est celui de l'autre diviseur. Seul diviseur1 est affiché par l'applet ci-dessous.


Les "heads" des 2 diviseur détectent chacune le débordement pour afficher ensemble

un indicateur à 3 valeurs: 'K' le chiffre de diviseur1 est correct (divisieur2 déborde), 'G' le chiffre de diviseur2 est correct (diviseur1 déborde), 'P' propager l'indicateur suivant (pas de débordement). Chaque fois qu'un diviseur déborde, il importe le reste partiel R de l'autre diviseur. L'indication "Overflow" sur une cellule "head" signale un débordement fatal de diviseur1 et de diviseur2 simultanément. La résolution des 'P', 'K', 'G' est semblable à la propagation de retenue de l'addition.

Calcul de Arc

Tangente Pour calculer l' ArcTangente(Y) on part du vecteur d'extrémité (1, Y). L'angle formé par ce vecteur avec l'axe horizontal a la valeur cherchée. Pour mesurer cet angle, on fait subir au vecteur une suite de "pseudoRotations" pour l'amener à l'horizontal, et on cumule les angles arctg (2-j ) de ces "pseudoRotations" (la constante k n'intervient pas).si Yj > 0 alors { Xj+1 = Xj + Yj * 2-j ; Yj+1 = Yj – Xj * 2-j ; Aj+1 = Aj – arctg(2-j ) ; } sinon { Xj+1 = Xj – Yj * 2-j ; Yj+1 = Yj + Xj * 2-j ; Aj+1 = Aj + arctg(2-j ) ; }


Sinus, Cosinus

et Arc Tangente Le "Nombre de bits" fixe à la fois la précision des calculs et le nombre de pas. En cliquant flèche verticale on change la présentation. La touche "Mise à zéro" permet le contrôle 'à la main' de la convergence.

Calcul de Arc

Sinus Pour calculer l' ArcSinus(S) on part vecteur horizontal de module k et on lui fait subir une suite de "pseudoRotations" pour amener son module à 1 et l'ordonnée Y de son extrémité à S. L'angle formé par ce vecteur avec l'horizontale a la valeur cherchée.


Cet algorithme donne un résultat médiocre. En effet le vecteur est trop court (son module

croit de 0,858773 à 1) pour que son extrémité soit sur le cercle et en conséquence la comparaison de l'ordonnée Y de son extrémité avec S est parfois erronée. A chaque itération, le module du vecteur est multipliée par 1+ 2-2j, multiplier S par la même constante rendrait la comparaison totalement pertinente. La "double rotation" rend cette multiplication plus sympathique. En effet la multiplication par le carré de cette constante se réduit à une addition. Dans la figure tous les vecteurs sont dessinés avec le même module car sur le dessin leurs coordonnées sont divisés par les constantes successives, ce qui fait que S ne bouge pas.

X1 = 1 ; Y1 = 0 ; A1 = 0 ; S1 = S ;

si Yj > Sj alors { Aj+1 = Aj – 2 * arctg(2-j ) ; Sj+1 = Sj + Sj * 2-2j ; Xj+1 = Xj + 2 * Yj * 2-j – Xj * 2-2j ; Yj+1 = Y – 2 * Xj j * 2-j – Yj * 2-2j } sinon {Aj+1 = Aj + 2 * arctg(2-j ) ; Sj+1 Xj+1 = Xj – 2 * Yj * 2-j – Xj * 2-2i ; Yj+1 = Yj + 2 * Xj * 2-j – Yj * 2-2j }

= Sj + Sj * 2-2i ;


Table Bipartite

On peut précalculer puis stocker les valeurs d'une fonction en table, cependant la taille de cette table croît très vite avec la précision requise, ce qui limite en pratique cette approche. Pour des fonctions continues avec une faible variation de pente (cas de nombreuses fonctions), on peut ne stocker que la position de segments dans une première table "TIV", et le ou les segment(s) dans une autre table "TO". L'applet ci-dessous rempli les tables pour les fonctions et les intervalles listés à gauche et permet d'observer graphiquement le résultat. La valeur des tables est imprimable en VHDL. La fonction arcsin(x) présente une très forte variation de pente quand x approche 1, elle illustre autour de cette valeur les limites de la compression de table par bipartition.


Représentation modulaire

Soit un ensemble { m1, m2, m3, ... mn} de n constantes entières premières entre elles appelées moduli et soit M le produit de ces constantes, M = m1* m2* m3* ... * mn. Soit une variable entière A inférieure à M. A peut s'écrire ( a1 | a2 | a3 |....| an )RNS où ai = A modulo mi (résidu). Cette définition dit comment calculer les ai à partir de A. Il est également possible de retrouver A à partir des ai en utilisant une autre série de constantes { im1, im2, im3, ... imn} précalculées appelées "inverses modulo M" des premières. A = | a1 * im1 + a2 * im2 + a3 * im3 + ..... an * imn | modulo M Ce résultat de réversibilité est démontré par le "théorème des restes chinois" .Vérifiez que vous vous maîtrisez cette représentation en convertissant A de décimal à RNS ou bien de RNS à décimal

Addition

modulaire L'addition modulaire utilise n petits additionneurs calculant simultanément toutes les sommes si = ai + bi modulo mi .


Soustraction

modulaire La soustraction modulaire utilise n petits soustracteurs calculant simultanément toutes les différences di = ai + mi - bi modulo mi .

Multiplication

modulaire La multiplication modulaire utilise n petits multiplieurs calculant simultanément tous les produits pi = ai * bi modulo mi .


Conversion en

RNS La conversion d'une variable A binaire en RNS consiste à trouver les ai = A modulo mi qui sont les restes de la division de A par mi. Tous ces calculs peuvent se faire simultanément, cependant utiliser des diviseurs n'est pas la meilleure méthode. • le reste modulo 2n est immédiat, • le reste modulo 2n – 1 ne demande que des additions, • le reste modulo 2n + 1 demande des additions et soustractions. autrement on se ramène à celui des deux deniers qui a le n le plus petit. Des arbres d'additionneurs (arbres de Wallace) réduisent A à la somme de 2 entiers de n bits sans changer le reste modulo mi. Les conventions graphiques sont celles de la réduction des produits partiels.

Réducteur

modulo 2n – 1 L'applet ci-dessous réduit 64 bits en 6 bits en en conservant la valeur modulo 63 (63 = 26 – 1) . En sortie zéro a deux notations: "000 000" ou encore "111 111"


Additionneur modulo 2n – 1

L'additionneur "à rebouclage de retenue" ci-dessus offre deux avantages : il fonc-tionne correctement et il est simple, et aussi deux inconvénients: il est lent et difficilement testable, et ce pour la même raison : il y a pour la valeur zéro deux états stables. Un additionneur rend spontanément une somme modulo 2n. Avec une légère modification l'additionneur de Sklansky à retenue entrante retardée rend une somme modulo 2n – 1.

• si A + B < 2n – 1 alors S = A + B ; • si A + B ≥ 2n – 1 alors S = A + B + 1 modulo 2 n ;

Dans les deux cas on a S = A + B modulo (2 n– 1). La condition est donnée par la retenue cn: si cn = 'K' alors A + B < 2n – 1, si cn = 'P' alors A + B = 2n – 1, si cn = 'G' alors A + B > 2n – 1. Donc le signal "rebouclage" qui contrôle " +1" vaut 'K' si cn = 'K' et vaut 'G' autrement.


Multiplieur

modulo 2n – 1 La multiplication de deux nombres de n bits modulo 2n – 1 déroule 3 étapes :

• production de n2 produits partiels modulo 2n – 1 • réduction de ces n2 produits partiels 2n – 1 en 2 nombres de n bits • addition de ces deux nombres modulo 2n – 1 avec l'additionneur précédent.

Réducteur de

produits partiels modulo 2n– 1

La réduction des n2 produits partiels est semblable à celle de le multiplication rapide et les conventions graphiques sont les mêmes.


Réducteur

modulo 2n + 1 L'applet suivant réduit 64 bits en 7 bits en conservant la valeur modulo 65 (65 = 26 + 1


Il dérive du réducteur précédent en complémentant logiquement tous les bits de rang entre 6(2k + 1) et 6(2k + 1) + 5. On ne peut pas reboucler la retenue de l'additionneur terminal, il faut au contraire l'ajouter au résultat de cet additionneur ce qui donne un nombre de 7 bits.

Additionneur modulo 2n + 1

On peut remplacer l'additionneur terminal de la figure ci-dessus par un additionneur modulo 2n + 1 :

• si A + B < 2n + 1 alors S = A + B ; • si A + B ≥ 2n + 1 alors S = | A + B – 1 | modulo 2n ;

On se ramène à l'additionneur modulo 2n – 1 en calculant préalablement sans propagation de retenue deux nombres X et Y tels que X + Y = A + B + 2n – 1 avec les cellules HA' , duales de HA.

• si X + Y < 2n + 1 alors S = | X + Y + 1 | modulo 2n; • si X + Y ≥ 2n + 1 alors S = | X + Y | modulo 2n;

Donc le signal "rebouclage" qui contrôle "+1" est le "nand" de xn et (cn = 'K' ). Le bit poids fort sn est le "and" de xn et (cn = 'P' ) .

Multiplieur

modulo 2n + 1 La génération des n2 produits partiels modulo 2n-1 + 1 ajoute un biais valant 2n + 2n-1

– n – 2. Le produit sera compensé de ce biais lors de la réduction des produits partiels.


Réduction des

produits partiels modulo 2n + 1

L'applet réduit (n-1)*(n+1) +1 bits à deux nombres de n–1 bits chacun modulo 2n-1+ 1. Les deux nombres en sortie sont à cumuler avec l'additionneur précédent. Cette réduction ajoute un second biais valant n (nombre de rebouclages). La compensation des deux biais consiste à ajouter 5 lors de la réduction.

Conversion de

"RNS" en base La notation "base mixe" ("MRS") est une notation de position avec les poids (1) (m1) (m1m2) (m1m2m3) (m1m2m3.....mn-1 ).


mixe "MRS" Dans cette notation X s'écrit ( z1 | z2 | z3 |....| zn )MRS où 0 ≤ zi < mi. Remarquer que le domaine des chiffres "MRS" est le même qu'avec le "RNS" , mais les chiffres eux-mêmes sont différents. La valeur X = z1 + m1 * (z2 + m2 * (z3 + m3 * ( ..... ))).


Documents

cours est imprimable