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 touches
permettent 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.
Opérateurs Arithmétiques Page 2
Délai et Nous venons de voir que l'inverseur n'a pas de dissipation d'énergie sauf lorsqu'il
consommation de commute. En effet si l'entrée vaut '0' ou '1' il n'y a pas de chemin de conduction
l'inverseur CMOS 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 A
Enfin 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".
Opérateurs Arithmétiques Page 3
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 Quand vous cliquez dans le chronogramme ci-dessous, vous tracez la tension de
électrique de l'entrée "a" de l'inverseur (tracé en rouge sur le chronogramme). La tension de la
l'inverseur CMOS 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 Nous allons étudier maintenant les portes logiques de base en CMOS:
NOR et NAND 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.
Opérateurs Arithmétiques Page 4
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 La porte CMOS à 2 entées est l'une des portes les plus simples pour illustrer le
entrées 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 Dans le NAND à 2 entrées, les transistors canal P sont reliés en parallèle alors que
entrées les transistors canal N sont reliés en série.
L'additionneur La cellule "FA" (Full Adder) est formée de deux portes complexes connectées. Elle
binaire réalise une égalité arithmétique: la somme pondérée des 3 entrées "x", "y" et "z" a
Opérateurs Arithmétiques Page 5
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.
Opérateurs Arithmétiques Page 6
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 à L'addition est de très loin l'opération arithmétique la plus commune des processeurs
propagation 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.
Opérateurs Arithmétiques Page 7
Additionneur La flèche verticale à côté du bouton de l'additionneur fait apparaître une double
signé 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 Soit un additionneur à propagation à travers n cellules "FA", si on suppose que
l'additionneur à toutes les valeurs de A et B sont équiprobables et indépendantes, les résultats
propagation théoriques suivants viennent:
minimum
moyen
maximum
délai
0
log2(n)
n
activité
0
3n / 4
n /2
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 Pour chaque cellule "FA" un des 3 cas se produit :
de la retenue • 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 .
Opérateurs Arithmétiques Page 8
Cellule "BK" La cellule "BK" permet de calculer la retenue pour un bloc de 2 cellules "FA" ou plus
(Brent et Kung) généralement pour 2 blocs de cellules "FA".
Additionneur de Pour concevoir un additionneur rapide, on va calculer toutes les retenues ci par des
Sklansky 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".
Opérateurs Arithmétiques Page 9
Additionneurs Il y a une seule règle de construction des arbres imbriqués de cellules "BK":
rapides Toute sortie de rang i est reliée à toutes les entrées de rang j ≤ i par un arbre planaire
(Brent et Kung) 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 Les arbres binaires de cellules "BK" des additionneurs de Kogge et Stone ne
de Kogge et partagent pas. En conséquence la sortance des signaux est réduite au minimum au
Opérateurs Arithmétiques Page 10
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 Dans un additionneur de Ling, les arbres de "BK" calculent une primitive appelée
Ling "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 Pour éditer la table qui décrit les arbres de "BK", cliquer dans une case puis enter la
de cellules "BK" 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 La cellule "CS" ne propage pas la retenue de l'entrée "e" vers la sortie "h". Elle permet
sans donc de réaliser des additionneurs sans propagation de retenue. Le nombre de cellules
Opérateurs Arithmétiques Page 11
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
n
même valeur a plusieurs écritures (sauf 2 – 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 On appelle "hybride" les opérateurs acceptant des écritures différentes. Dans l'additihybride onneur ci-dessous, d'ailleurs très simple et très rapide, A est en binaire, alors que B et S
sont en "CS
Opérateurs Arithmétiques Page 12
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' .
Opérateurs Arithmétiques Page 13
Additionneurs spéciaux
Additionneurs Certains algorithmes arithmétiques peuvent être réalisées en modifiant un additionneur.
spéciaux Par exemple :
n
n
n
•
si A + B < 2 alors S = A + B sinon S = A + B – 2 ; // addition modulo 2
•
•
•
•
•
•
•
•
si A + B < 2 alors S = A + B sinon S = 2 – 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
n
n
n
si A + B < 2 – 1 alors S = A + B sinon S = A + B – 2 + 1 ; // modulo 2 – 1
n
n
n
n
n
• si A + B < 2 + 1 alors S = A + B sinon S = A + B – 2 – 1 ; // modulo 2 + 1
Le coût et le délai du nouvel opérateur restent proches de ceux d'un additionneur.
n
Addition avec Si on néglige la retenue sortante cn alors un additionner donne A + B – 2 lorsque A +
saturation B est trop grand. Pour conserver la continuité de lan sortie S et minimiser son erreur
moyenne, on préfère parfois à l'addition modulo 2 l'addition avec saturation à la plus
grande valeur que l'on peut écrire sur n bits : S = min ( A + B , 2n – 1) .
n
Additionneur/ Les additionneurs font spontanément les additions modulo 2 . Pour obtenir l'opposé -B
soustracteur d'un nombre B, on complémente logiquementntous ses bits puis on lui ajoute 1.
L'addition de B et de -B obtenu ainsi donne 2 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.
Opérateurs Arithmétiques Page 14
Débordement de Si les valeurs de la retenue cn et de la retenue cn-1 diffèrent, il y a un débordement et
fausse:
l'addition/ la somme S est arithmétiquement
n
•
'0'
'1'
:
il
faut
ajouter
2
à
la
somme pour la corriger (débordement négatif)
soustraction
n
• '1' '0' : il faut soustraire 2 à la somme pour la corriger (débordement positif)
d'entiers signés
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é.
Opérateurs Arithmétiques Page 15
Plus grand de A Pour comparer deux nombres A et B, il n'est pas nécessaire de calculer complètement
ou de B 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 Si la retenue entrante c0 d'un additionneur est prête plus tard que les entrées A et B,
retenue entrante on utilise un additionneur à retenue entrante retardée est adéquat. Le délai entre
retardée l'entrée co et les sorties S est petit et indépendant du nombre de bits.
Opérateurs Arithmétiques Page 16
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 à Pour obtenir cet additionneur, on duplique les sorties de l'additionneur S = A + B + c0.
deux sorties Puis pour la sortie S on substitue à c la valeur '0' et pour l'autre sortie S' on substitue
0
à 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'.
Opérateurs Arithmétiques Page 17
Additionneur à On veut calculer S = A + B, S' = A + B + 1, S" = A + B + 2. Pour calculer S et S" on
trois sorties calcule préalablement sans propagation de retenue deux nombres X et Y tels que
X + Y = A + B. On obtient ainsi s0 et s0". 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 s0' 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
Opérateurs Arithmétiques Page 18
n
S" = A + B + 1 en calculant deux nombres X et Y tels que X + Y = A + B + 2 – 1
avec les cellules HA' , duales des cellules HA.
Valeur absolue Avec quatre légères modifications l'additionneur de Sklansky à retenue entrante
de la différence 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 Soit sa et sb les signes de A et B respectivement et Ma et Mb leurs valeurs absolues
représentation aussi appelées "magnitudes". L'addition de A et B est réalisée par l'addition de M et
a
"signe valeur
M si A et B sont de même signe, et par leur soustraction dans le cas contraire. Dans
absolue" b
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.
Opérateurs Arithmétiques Page 19
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 Un additionneur rend spontanément une somme modulo 2n. Avec une légère
n
modification l'additionneur de Sklansky à retenue entrante retardée rend une somme
n
modulo 2 – 1
modulo 2 – 1.
Opérateurs Arithmétiques Page 20
n
• si A + B < 2 – 1 alors S = A + B ;
n
• si A + B ≥ 2 – 1 alors S =  A + B + 1  modulo 2n ;
Dans les deux cas on a S =  A + B  modulo (2n– 1).
n
La condition du test est donnée par la retenue cn: si cn = 'K' alors A + B < 2 – 1, si cn
n
n
= 'P' alors A + B = 2 – 1, si cn = 'G' alors A + B > 2 – 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
n
modulo 2 + 1
n
•
si A + B < 2 + 1 alors S = A + B ;
•
si A + B ≥ 2 + 1 alors S =  A + B – 1  modulo 2n;
n
n
On se ramène à l'additionneur modulo 2 en calculant préalablement sans
n
propagation de retenue deux nombres X et Y tels que X + Y = A + B + 2 – 1 + c0
avec les cellules HA' , duales de HA. La retenue entrante c0 vaut '0'.
n+1
si X + Y < 2 alors S =  X + Y + 1  modulo 2n ;
n+1
si X + Y ≥ 2
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' ) .
n
Les valeurs de A et B vont de 0 à 2 . Les bits an et bn manquent en entrée de
n
l'additionneur ci-dessus. Ces deux bits manquant indiquent A = 2 et B = 2
respectivement.
n
n
n
n
si A = 2 et B = 2 alors ( A + B ) modulo 2 + 1 = 2 – 1.
n
n
n
n
si A = 2 et B < 2 alors A se réécrit ( 2 – 1 ) + 1, c'est à dire tous les bits ai sont
forcés à '1' ainsi que la retenue entrante c0.
Opérateurs Arithmétiques Page 21
n
n
n
si A < 2 et B = 2 alors B se réécrit ( 2 – 1 ) + 1, c'est à dire tous les bits bi sont
forcés à '1' ainsi que la retenue entrante c0.
Opérateurs Arithmétiques Page 22
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
2
chacun, on utilise n portes "AND" qui multiplient chaque bit de A par chaque bit
2
de X. La somme pondérée de ces n 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.
n
n
2n
Comme A < 2 et X < 2 , le produit P < 2 et s'écrit donc sur 2n bits.
Multiplication Une structure régulière de portes "AND" et de cellules "FA" formant un assemblage
sans signe "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"
2
strictement nécessaire est n – 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 Si le multiplicande A et le multiplieur X sont en complément à 2, alors les produits
n
signée avec les bits de signe an-1 et xn-1 doivent être inversés et la constante 2 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é.
Opérateurs Arithmétiques Page 23
Multiplieurs Plusieurs pistes conduisent à une amélioration de la vitesse:
• Diviser le nombre de bits à réduire en utilisant des grandes bases.
rapides
•
•
•
•
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 Passer à une base de numération plus grande réduit mécaniquement le nombre de
Booth "BC" 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 Pour faciliter le produit d'un nombre par un chiffre "BC", on réécrit ce dernier en
convertisseur "signe/valeur absolue" grâce à une cellule "B2BC". La cellule "B2BC" convertit un
pour le calcul de produits partiels. La somme est
de "BC" chiffre "BC" en "signe/valeur absolue"
s
conservée: -2 × x3 + x2 + x1 = (-1) × ( 2 × M2 + M1 ) ;
Opérateurs Arithmétiques Page 24
La conversion de X requiert deux fois moins de cellules "B2BC" que de bits de X.
Multiplieur des La multiplication par un chiffre "BC" ∈ {-2, -1, -0, 0, 1, 2} rajoute 2 bits à ceux de A:
bits de A par un un pour avoir A ou bien 2A, un autre pour la retenue entrante en cas de soustraction.
chiffre "BC" 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 La première étape de la multiplication génère à partie de A et de X des bits dont la
produits partiels 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'
Opérateurs Arithmétiques Page 25
Les quatre derniers calculs sont signés.
Réduction des La deuxième étape de la multiplication réduit les produits partiels de l'étape
produits partiels 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 L'applet suivant réduit 82 produits partiels (par exemple le produit de deux nombres
de Wallace 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.
Opérateurs Arithmétiques Page 26
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.
Opérateurs Arithmétiques Page 27
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 Le multiplieur X et le multiplicande A sont tous les deux en "CS", c'est à dire avec
d'opérandes en des chiffres ∈ { 0, 1, 2}.
"CS" 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.
Opérateurs Arithmétiques Page 28
Réduction des Les produits partiels de la multiplication de nombres en "CS" sont simplement des
produits partiels 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.
Opérateurs Arithmétiques Page 29
Codeur Le transcodeur "CS2CS" passe de "CS" à "CS" en garantissant qu'en sortie un '2' est
"CS2CS" 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 Le transcodeur "CS2BC" passe de "CS" à "BC" , c'est à dire du code à retenue
"CS2BC" 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...
Opérateurs Arithmétiques Page 30
Opérateurs Arithmétiques Page 31
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
i
i
de valeur D, 2D, 4D, 8D, ... 2 *D marqués respectivement avec 1, 2, 4, 8, ... 2 .
i
En fait D est un nombre binaire, et 2 *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 La division est peu fréquente, cependant comme son délai d'exécution est bien plus
récurrentes 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 :
j-1
• Qj-1 = Qj + qj-1 × 2
j-1
• Rj-1 = Rj – qj-1 × D × 2
avec comme conditions initiales :
• Qn = 0
•
Rn = A.
Quand la récurrence se termine, on a Q = Q0 = Σj=0 qj * 2 . R = R0 est le reste de la
division.
n
Opérateurs Arithmétiques Page 32
j
Soustracteur Un "soustracteur conditionnel" donne le résultat S suivant:
conditionnel 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.
Opérateurs Arithmétiques Page 33
Cellule "SC" du Vérifiez que vous maîtrisez les fonctions logiques de la cellule "SC" :
soustracteur si q = '0' alors { co = majorité ( r, –d, ci ) ; s = r } // identité
conditionnel
–
–
sinon { co = majorité ( r, d, ci ) ; s = r ⊕ d ⊕ ci } // soustraction
Diviseur avec Un diviseur "avec restauration" consiste en une suite de décalages et de tentative de
restauration 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 Si on retourne le diviseur "avec restauration" tête en bas et replace les soustracteurs
division 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 .
Opérateurs Arithmétiques Page 34
Opérateurs Arithmétiques Page 35
Diviseur sans Un diviseur "sans restauration" consiste en une suite de décalages et d'additions ou de
restauration 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
Opérateurs Arithmétiques Page 36
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 Pour avoir un diagramme de Robertson carré, on normalise les restes successifs:
-j
Robertson ( Rj × b ) 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 Trois approches se combinent pour réaliser des diviseurs rapides:
• Utiliser des additions/soustraction sans propagation de retenue.
rapides
•
•
Préconditionner le diviseur et le dividende pour simplifier la division.
Utiliser des grandes bases pour diminuer le nombre d'étapes.
Opérateurs Arithmétiques Page 37
Division "SRT" Pour éviter le délai dû à la propagation de retenue, on utilise ici une suite
sans d'additionneur/soustracteur à emprunt conservé ("BS"). La cellule "tail" , variante de la
bits de commande qui la traversent:
propagation de cellule "SC", exécute suivant les deux
j-1
• une addition : Rj-1 = Rj + 2 * D
retenue
j-1
•
une soustraction : Rj-1 = Rj – 2
•
une identité : Rj-1 = Rj
*D
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/ Un "additionneur/soustracteur conditionnel" donne l'un des résultats S suivant:
• si q = '1' alors S = R – D ; // soustraction
Soustracteur
• si q = '0' alors S = R ;
// identité
conditionnel sans
–
• si q = '1 ' alors S = R + D ; // addition
propagation
Opérateurs Arithmétiques Page 38
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 Vérifiez que vous maîtrisez les fonctions logiques de la cellule "tail" .
—
• si q = '1' alors 2*s1 – s0 = d0 + r0 ; // soustraction
diviseur "SRT"
•
•
// identité
si q = '0' alors 2*s1 – s0 = r0 ;
–
si q = '1' alors 2*s1 – s0 = d0 + r0 ; // addition
Opérateurs Arithmétiques Page 39
^
^
Cellule de tête du Soient R = r2* 4 + r1* 2 + r0 et S = s2* 4 + s1* 2 + s0 les valeurs respectivement des
diviseur "SRT" entrées et des sorties de la cellule de tête.
•
•
^ > 0 alors { S
^=R
^ – 2 ; q = '1' ; }
si R
^ = 0 alors { S
^=R
^ ; q = '0' ; }
si R
^ < 0 alors { S
^=R
^ + 1 ; q = '1–' ; }
si R
•
Lors d'une division correcte (sans débordement), la sortie s2 est toujours à 0. Cependant le débordement est utilisé dans la "double division" pour le calcul de sinus.
Cellules "head" Une cellule "head" suivie de cellules "tail" exécutent ensemble l'algorithme :
^ > 0 alors S = R – D ; // soustraction
et "tail"
• si R
•
•
^ = 0 alors S = R ;
si R
^ < 0 alors S = R + D ; // addition
si R
Nécessité du '0' Si R > 0 il ne faut pas faire d'addition et si R < 0 il ne faut pas faire de soustraction
dans l'écriture sous peine de débordement. Quand = 0, le signe de R n'est pas connu, donc on ne
de Q 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
Nécessité de la 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 à
normalisation faciliter la réalisation: moins il y a de chiffres de D avant la virgule et moins il y a de
du diviseur D chiffres de R a examiner par "head" et plus le circuit est rapide, donc 1 ≤ D < 2 , D
est "normalisé"
Opérateurs Arithmétiques Page 40
Division "SRT" La division "SRT" précédente est simple car le premier bit du diviseur D est toujours
avec réduction '1'. Elle se simplifie davantage si les deux premiers bits d0 et d1 du diviseur D sont
du diviseur 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é.
n-1
n-1
n-2
Pour un diviseur sur n bits, 2 – 1 < D < 2 + 2 .
^ =r
Cellule de tête du Soient R
1* 2 + r0 la valeur de l'entrée de la cellule de tête "head".
diviseur "SRT"
^
^
• si R > 1 alors { s0 = R – 3 ; q = '1' ; }
avec réduction
^ = 1 alors { s
• si R
q=-0;}
0=0;
–
^ = 0 alors { s = 0 ;
q = + 0 ; } ou bien { s0 = '1' ; q = - 0 ; }
• si R
0
^ = -1 alors { s = -1 ; q = + 0 ; }
• si R
0
–
^ < -1 alors { s
^
• si R
0 = R + 2 ; q = '1' ; }
La différence entre les deux écritures de 0 pour q : "- 0" et "+ 0" importe.
Opérateurs Arithmétiques Page 41
Convertisseur Le quotient Q du diviseur SRT est en notation redondante. Sa conversion en notation
de quotient 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.
Opérateurs Arithmétiques Page 42
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.
Opérateurs Arithmétiques Page 43
Extracteur de racine carrée
Extraction de L'extraction de racine carrée est relativement peu fréquente. Cependant elle intervient
racine carrée 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 Dans le dessin ci-dessous, la surface de chaque rectangle rouge représente le poids de
d'extraction de un bit. Seuls les bits à '1' sont dessinés. La surface totale dessinée est donc la somme
racine carrée 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 On veut calculer Q = A . Ceci est équivalent à Q = A ÷ Q. Donc si Q s'écrit sur n
racine carrée 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 :
j-1
• Qj-1 = Qj + qj-1 * 2
j-1
j-1
• R2j-2 = R2j – qj-1 * 2 * ( 2 * Qj + 2 )
avec comme conditions initiales :
• Qn = 0
• R2n = A.
j
n
Quand la récurrence se termine, on a Q = Q0 = Σj=0 qj * 2 .
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:
Opérateurs Arithmétiques Page 44
•
•
Qj-1 = Qj & qj-1
j
R2j-2 = R2j – qj-1* 2 * ( 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.
Opérateurs Arithmétiques Page 45
• 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 L'extracteur de racine carrée sans restauration utilise les mêmes cellules
restauration d'addition/soustraction "AS" que le diviseur sans restauration.
• si R2j ≥ 0 alors { qj-1 = '1' ; R2j-2 = R2j – ( Qj & 0 1 ) } //soustraction
–
• si R2j < 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") .
Extracteur On cherche à s'affranchir de la propagation de retenue en utilisant la notation "BS",
de racine carrée les mêmes cellules "head" et "tail" et une architecture similaire à celle de la division
rapide rapide. On se heurte à trois difficultés en cherchant à utiliser ce diviseur pour extraire
des racines.
Opérateurs Arithmétiques Page 46
Convertisseur La première difficulté est le rebouclage de la racine. Comme le diviseur, l'extracteur
de racine 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 Vérifiez que vous maîtrisez les fonctions logiques de la cellule "trc" de conversion de
convertisseur de notation "BS" vers notation binaire conventionnelle.
racine 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
Opérateurs Arithmétiques Page 47
Extracteur de L'extracteur rapide utilise les mêmes cellules que le diviseur rapide pour effectuer à
racine carrée chaque itération une des opérations arithmétiques :
j
2j-1
–
sans
• si qj = '1' alors R2j-2 = R2j + 2 * Qj – 2
// addition
propagation de
• si qj = '0' alorsR2j-2 = R2j // identité
retenue
j
2j-1
•
si qj = '1' alors R2j-2 = R2j – 2 * Qj – 2
//soustraction
2j-1
La deuxième difficulté par rapport à la division est dans la soustraction de 2
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.
^ du
Chaque cellule "head" détermine un qj grâce à la valeur d'un approximant R
2j
reste courant R2j limité aux 3 premiers chiffres de R2j.
Opérateurs Arithmétiques Page 48
La deuxième difficulté de l'extraction de racine par rapport à la division est dans la
2j-1
–
soustraction de 2
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 Le même circuit peut exécuter soit la division soit l'extraction de racine carrée grâce
extracteur de à des multiplexeurs "2 ⇒ 1" insérés sur les entrées de certaines cellules "tail". La
racine carrée 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
Opérateurs Arithmétiques Page 49
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.
Opérateurs Arithmétiques Page 50
Addition en Virgule Flottante
Format des Trois champs composent l'écriture binaire des nombres en virgule flottante. Le signe
nombres en S (1 bit), l'exposant E (8 bits) et la mantisse M, ou significande (23 bits).
S
(E - 127)
virgule flottante La valeur du nombre est (-1) * 2
* (1 + M / 8388608 ) . Cependant si E = 0,
S
(-126)
le nombre dénormalisé vaut (-1) * 2
* ( 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 Les réels étant codés en "signe/valeur-absolue", un seul bit permet de changer le
soustraction 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.
Opérateurs Arithmétiques Page 51
Additionneur/ Un additionneur flottant est formé des blocs ci-dessous:
soustracteur 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".
Opérateurs Arithmétiques Page 52
Compteur de Un arbre binaire décompte le nombre de '0' en poids forts de la chaîne de bits S par
zéros en tête dichotomie. Si la taille des sous-chaînes est une puissance de 2, alors il n'y a pas
( ZLC ) 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 Cette cellule combine le nombre de '0' en poids forts de chacune de deux chaînes de
compteur de longueur 16 pour obtenir le nombre de '0' en poids forts de la concaténation des deux
zéros en tête chaînes.
. si X < 16 alors S = X sinon S = 16 + Y
Opérateurs Arithmétiques Page 53
Prédiction de A partir des mantisses A et B on peut construire une chaîne de bits P ayant (à 1 près)
zéros en tête 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.
Opérateurs Arithmétiques Page 54
Cellule de 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'*
prédiction et des '0' à l'intérieur de celle-ci.
Ajustement de Ce circuit rend 'Y' si la prédiction du nombre de zéros en tête est fausse, donc trop
zéros en tête 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 Le Bloc1 calcule la valeur absolue de la différence des exposants pour commander le
de la différence 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
Opérateurs Arithmétiques Page 55
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 Pour éviter la propagation de retenue au cours de l'arrondi, on pré-calcule avec un
l'arrondi 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
Opérateurs Arithmétiques Page 56
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)
Opérateurs Arithmétiques Page 57
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
Opérateurs Arithmétiques Page 58
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
Opérateurs Arithmétiques Page 59
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
Opérateurs Arithmétiques Page 60
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)
Opérateurs Arithmétiques Page 61
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' ,
Opérateurs Arithmétiques Page 62
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 ;
Opérateurs Arithmétiques Page 63
Fonctions élémentaires
Fonctions On réalise les fonctions Exponentielle, Logarithme, Sinus, Cosinus et Arc
élémentaires 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 Supposons qu'on veuille calculer X = exp ( Y ). On dispose d'une balance, d'un
pain à pain dont-jle poids est justement Y et enfin d'une série de poids de valeur
l'exponentielle log(1 + 2 ). 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 On remplace la balance par un diviseur "SRT" dont voici le "diagramme de
propagation pour Robertson".
l'exponentielle
Opérateurs Arithmétiques Page 64
Diviseur "SRT" Le dividende Y (en haut) est dans l'intervalle ] -1 , +1 [ Les constantes log(1 + 2-j )
pour et -log(1 – 2-j ) entrant dans les cellules "tail" sont câblées. Il y a donc 4 variantes
l'exponentielle de la cellule "tail" fonction des valeurs de 2 bits.
^ , somme pondérée des
Opération d'une Chaque q est choisi par une cellule "head" en fonction de R
j
j
tranche de
2 chiffres poids forts r1 et r0 de l'écriture de Rj.
diviseur "SRT"
^ – 2 ; R = R + log(1 – 2-j ) } //
^ > 0 alors { q = '1' ; s = R
si R
j
j
0
j
j+1
j
pour •
soustraction
l'exponentielle
•
•
^ = -1 alors { q = '0' ; s = R
^ ; R = R + 0 } // identité
^ = 0 ou R
si R
j
j
j
0
j
j+1
j
-j
–
^
^
si Rj < -1 alors { qj = '1' ; s0 = Rj + 2 ; Rj+1 = Rj + log(1 + 2 ) } //addition
Opérateurs Arithmétiques Page 65
Suite de La suite de multiplications conditionnelles par 1, par (1 + 2-j ) ou par (1 – 2-j )
multiplications 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 Les tableaux ci-dessous montrent les restes partiels du diviseur "SRT" ("BS") puis les
numérique produits partiels ("CS") pour le calcul d'exponentielle. La fenêtre du bas permet de
d'exponentielle comparer -jla valeur "vraie"-jde l'exponentielle au produit de multiplications tronquées
par (1 + 2 ) ou par (1 – 2 ).
Opérateurs Arithmétiques Page 66
On a entré Y = 0,7 dans le diviseur, en fait 0.101100110011001100110011011sur 28 bits (0.6999999843).
-- -- -- - - --Le quotient sur 28 chiffres s'écrit 1000111011001101010011000111 et donnerait 2,0137522695814808.
-- -- -- - En ne gardant que 18 chiffres 100011101100110101 on obtient finalement X= 2,01375556178391 dont le
logarithme vaut environ 0,70000141740909895
Opérateurs Arithmétiques Page 67
Extension du Le circuit précédent fonctionne pour Y dans l'intervalle ] -1 , +1 [ . Pour
domaine l'exponentielle d'un nombre Y quelconque, on écrit Y = Q*log(8) + R, où Q est leQ
quotient entier de la division de Y par log(8) et R < log(8) < 1. Alors exp(Y) = 8 *
3Q
exp(R) = 2 * 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
-j
-j
–
constantes sont log(1 + 2 ) et -log(1 – 2 ) 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
Opérateurs Arithmétiques Page 68
De la pesée du On veut calculer sin ( A ) et/ou cos ( A ). On dispose d'une balance, d'un pain dont le
-j
pain au sinus et poids est justement A et enfin d'une série de poids de valeur ArcTangente( 2 ). Les
au cosinus 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
Opérateurs Arithmétiques Page 69
et Cosinus (2-j) donne Vj+1 d'extrémité Xj+1 = Xj – Yj * 2-j et Yj+1 = Yj + Xj * 2-j.
-j
En décomposant un angle A en une somme pondérée d'arctg (2 ), 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
-2j
1+2
, 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
-j
–
base arctg(2 ) utilise des chiffres ∈{ '1', '1' } .
Décomposition Quel est le domaine des angles A = Σ n a arctg (2-j) et quelle précision espérer de
j=0 j *
d'un angle 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
-j
base arctg (2 ).
Opérateurs Arithmétiques Page 70
"Diagramme de Le "diagramme de Robertson" montre que l'itération de conversion de l'angle dans la
-j
Robertson" base arctg(2 ) peut être choisie comme suit:
-j
-j
–
pour sinus et
si R ≥ 0 alors { S = R – arctg(2 ) ; aj = '1' } sinon { S = R + arctg(2 ) ; aj = '1' }.
cosinus
Diviseur "sans L'angle A (en haut du diviseur) est dans l'intervalle [ -1,743.. +1,743...]. Les bits
restauration" de constants entrant dans les cellules "AS" sont câblés. Les opérations sont choisies par
sinus et cosinus le signe des restes partiels R précédent et par y0 pour la première opération .
Opérateurs Arithmétiques Page 71
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)
-j
-j
si aj = '0' alors { Xj+1 = Xj – Yj * 2 ;Yj+1 = Yj + Xj * 2 }
-j
-j
–
si aj = '1' alors { Xj+1 = Xj + Yj * 2 ; Yj+1 = Yj – Xj * 2 }.
-j
Pour simplifier le dessin, la nappe X * 2 n'y figure pas toujours complètement.
Opérateurs Arithmétiques Page 72
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
Opérateurs Arithmétiques Page 73
"Diagramme de On utilise une approximation ^R du reste R pour déterminer la rotation:
Robertson" ^
–
^
^
pour CORDIC à si R > 0 alors aj = '1' ; si R = 0 alors aj = '0' ; si R < 0 alors aj = '1' ;
"double On constate sur le diagramme que l'approximation peut être grossière.
rotation"
CORDIC à Ce diviseur a les mêmes cellules "head" et "tail" que le diviseur "SRT". Pour
"double s'accommoder du '0', l'angle A est préalablement divisé par 2 et les
rotation" "pseudoRotations" sont doublées. Grâce à cela l'allongement reste le même
( 1 + 4 j )2 quelque soit aj.
-j
-j
–
• si aj = '1' alors { rotation de (arctg(2 )) puis rotation de (arctg(2 )) } ;
-j
-j
• si aj = '0' alors { rotation de (arctg(2 )) puis rotation de (-arctg(2 )) } ;
-j
-j
• si aj = '1' alors { rotation de (-arctg(2 )) puis rotation de (-arctg(2 )) } ;
Opérateurs Arithmétiques Page 74
La "double rotation" est coûteuse: elle double le matériel de la rotation et probablement le délai. En regroupant les lignes par deux elle se réécrit :
-j
-2j
-j
-2j
–
si aj = '1'alors {Xj+1 = Xj + 2 * Yj * 2 – Xj * 2 ; Yj+1 = Yj – 2 * Xj * 2 – Yj * 2 }
-2j
-2j
si aj = '0' alors {Xj+1 = Xj + Xj * 2 ; Yj+1 = Yj + Yj * 2 }
-j
-2j
-j
-2j
si aj = '1' alors {Xj+1 = Xj – 2 * Yj * 2 – Xj * 2 ; Yj+1 = Yj + 2 * Xj * 2 – Yj * 2 }
Cette réécriture ne change pas le nombre d'addition/soustraction sauf lorsque les
-2j
termes multiples de 2 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
-j
–
quotient qui marche avec les poids 2 ( '0' '1' = '1' '1' ) ne marche plus avec les
-j
poids arctg(2 ) .
CORDIC à La "double division" est plus astucieuse que la conversion. Elle utilise deux divi"double seurs fonctionnant simultanément avec des cellules "head" légèrement modifiées.
"head" de diviseur2
division" "head" de diviseur1
^ = ^R – 2 ; a
^ = ^R – 2 ; a = '1' ; }
si ^R > 0 alors { S
si ^R ≥ 0 alors { S
j = '1' ; }
j
–
–
^
^
^
^
^
^
si R ≤ 0 alors { S = R +1 ; aj = '1' ; }
si R < 0 alors { S = R +1 ; aj = '1' ; }
^ = 0, diviseur1 parie que R ≤ 0 et diviseur2 que R ≥ 0. L'un
Il est clair que lorsque R
des deux au plus se trompe et en conséquence peut déborder, avant ou en même
^ = 0 suivant. Au débordement on saura que le résultat
temps que l'apparition du R
correct est celui de l'autre diviseur. Seul diviseur1 est affiché par l'applet cidessous.
Opérateurs Arithmétiques Page 75
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 Pour calculer l' ArcTangente(Y) on part du vecteur d'extrémité (1, Y). L'angle formé
Tangente 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
-j
cumule les angles arctg (2 ) de ces "pseudoRotations" (la constante k n'intervient pas).
-j
-j
-j
si Yj > 0 alors { Xj+1 = Xj + Yj * 2 ; Yj+1 = Yj – Xj * 2 ; Aj+1 = Aj – arctg(2 ) ; }
-j
-j
-j
sinon { Xj+1 = Xj – Yj * 2 ; Yj+1 = Yj + Xj * 2 ; Aj+1 = Aj + arctg(2 ) ; }
Opérateurs Arithmétiques Page 76
Sinus, Cosinus Le "Nombre de bits" fixe à la fois la précision des calculs et le nombre de pas. En
et Arc Tangente 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 Pour calculer l' ArcSinus(S) on part vecteur horizontal de module k et on lui fait subir une
Sinus 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.
Opérateurs Arithmétiques Page 77
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
-2j
itération, le module du vecteur est multipliée par 1+ 2 , 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 ;
-j
-2j
si Yj > Sj alors { Aj+1 = Aj – 2 * arctg(2 ) ; Sj+1 = Sj + Sj * 2 ;
-j
-2j
-j
-2j
Xj+1 = Xj + 2 * Yj * 2 – Xj * 2 ; Yj+1 = Yj – 2 * Xj * 2 – Yj * 2 }
-j
-2i
sinon {Aj+1 = Aj + 2 * arctg(2 ) ; Sj+1 = Sj + Sj * 2 ;
-j
-2i
-j
-2j
Xj+1 = Xj – 2 * Yj * 2 – Xj * 2 ; Yj+1 = Yj + 2 * Xj * 2 – Yj * 2 }
Opérateurs Arithmétiques Page 78
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.
Opérateurs Arithmétiques Page 79
Représentation Soit un ensemble { m1, m2, m3, ... mn} de n constantes entières premières entre elles
modulaire appelées moduli et soit M le produit de ces constantes, M = m m m ... m .
1*
2*
3*
*
n
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 L'addition modulaire utilise n petits additionneurs calculant simultanément toutes les
modulaire sommes si =  ai + bi modulo mi .
Opérateurs Arithmétiques Page 80
Soustraction La soustraction modulaire utilise n petits soustracteurs calculant simultanément
modulaire toutes les différences di =  ai + mi - bi  modulo mi .
Multiplication La multiplication modulaire utilise n petits multiplieurs calculant simultanément tous
modulaire les produits pi =  ai * bi  modulo mi .
Opérateurs Arithmétiques Page 81
Conversion en La conversion d'une variable A binaire en RNS consiste à trouver les ai = A modulo
RNS m qui sont les restes de la division de A par m . Tous ces calculs peuvent se faire
i
i
simultanément, cependant utiliser des diviseurs n'est pas la meilleure méthode.
n
• le reste modulo 2 est immédiat,
•
n
le reste modulo 2 – 1 ne demande que des additions,
n
• le reste modulo 2 + 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 L'applet ci-dessous réduit 64 bits en 6 bits en en conservant la valeur modulo 63
6
n
modulo 2 – 1 (63 = 2 – 1) . En sortie zéro a deux notations: "000 000" ou encore "111 111"
Opérateurs Arithmétiques Page 82
Additionneur L'additionneur "à rebouclage de retenue" ci-dessus offre deux avantages : il foncn
modulo 2 – 1 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
n
stables. Un additionneur rend spontanément une somme modulo 2 . Avec une légère
modification l'additionneur de Sklansky à retenue entrante retardée rend une somme
n
modulo 2 – 1.
n
•
si A + B < 2 – 1 alors S = A + B ;
•
si A + B ≥ 2 – 1 alors S =  A + B + 1  modulo 2 n ;
n
Dans les deux cas on a S =  A + B  modulo (2 n– 1).
n
La condition est donnée par la retenue cn: si cn = 'K' alors A + B < 2 – 1, si cn = 'P'
n
n
alors A + B = 2 – 1, si cn = 'G' alors A + B > 2 – 1.
Donc le signal "rebouclage" qui contrôle " +1" vaut 'K' si cn = 'K' et vaut 'G'
autrement.
Opérateurs Arithmétiques Page 83
Multiplieur La multiplication de deux nombres de n bits modulo 2n – 1 déroule 3 étapes :
n
n
modulo 2 – 1
• production de n2 produits partiels modulo 2 – 1
•
n
réduction de ces n2 produits partiels 2 – 1 en 2 nombres de n bits
•
addition de ces deux nombres modulo 2 – 1 avec l'additionneur précédent.
n
2
Réducteur de La réduction des n produits partiels est semblable à celle de le multiplication rapide
produits partiels et les conventions graphiques sont les mêmes.
modulo 2n– 1
Opérateurs Arithmétiques Page 84
Réducteur L'applet suivant réduit 64 bits en 7 bits en conservant la valeur modulo 65 (65 = 26 + 1
n
modulo 2 + 1
Opérateurs Arithmétiques Page 85
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 On peut remplacer l'additionneur terminal de la figure ci-dessus par un additionneur
n
n
modulo 2 + 1 modulo 2 + 1 :
n
•
si A + B < 2 + 1 alors S = A + B ;
•
si A + B ≥ 2 + 1 alors S = | A + B – 1 | modulo 2n ;
n
n
On se ramène à l'additionneur modulo 2 – 1 en calculant préalablement sans
n
propagation de retenue deux nombres X et Y tels que X + Y = A + B + 2 – 1 avec
les cellules HA' , duales de HA.
n
• si X + Y < 2 + 1 alors S = | X + Y + 1 | modulo 2n;
n
• si X + Y ≥ 2 + 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' ) .
2
n-1
n
n-1
Multiplieur La génération des n produits partiels modulo 2 + 1 ajoute un biais valant 2 + 2
modulo 2n + 1 – n – 2. Le produit sera compensé de ce biais lors de la réduction des produits
partiels.
Opérateurs Arithmétiques Page 86
n-1
Réduction des L'applet réduit (n-1)*(n+1) +1 bits à deux nombres de n–1 bits chacun modulo 2 + 1.
produits partiels Les deux nombres en sortie sont à cumuler avec l'additionneur précédent. Cette
modulo 2n + 1 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 La notation "base mixe" ("MRS") est une notation de position avec les poids (1)
"RNS" en base (m1) (m1m2) (m1m2m3) (m1m2m3.....mn-1 ).
Opérateurs Arithmétiques Page 87
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 euxmêmes sont différents. La valeur X = z1 + m1 * (z2 + m2 * (z3 + m3 * ( ..... ))).
Opérateurs Arithmétiques Page 88