Additionneur

Un additionneur est un circuit logique servant à réaliser une addition.

On dénombre deux types d'additionneurs : parallèle (circuit combinatoire) et série (circuit séquentiel). Dans la classe des additionneurs parallèles, nous décrirons ici ceux à propagation de retenue et ceux à retenue anticipée.

Additionneur parallèle

Codée sur un bit, la table de vérité de l'addition est :

A	B	A + B	Retenue
0	0	0	0
0	1	1	0
1	0	1	0
1	1	0	1

Remarquons dans le tableau ci-dessus que A+B représente le poids faible alors que Retenue représente le poids fort.

Demi-additionneur

À partir de cette table de vérité on peut par exemple construire le circuit suivant, nommé «demi-additionneur» :

Additionneur complet

Un additionneur complet nécessite une entrée supplémentaire : une retenue. L'intérêt de celle-ci est de permettre le chaînage des circuits. La table de vérité d'un additionneur complet est :

A	B	REntrée	A xor B xor REntrée	RSortie
0	0	0	0	0
0	0	1	1	0
0	1	0	1	0
0	1	1	0	1
1	0	0	1	0
1	0	1	0	1
1	1	0	0	1
1	1	1	1	1

Le circuit correspondant, l'additionneur complet, se compose de deux demi-additionneurs en série accompagnés d'une logique pour calculer la retenue (un OU entre les deux retenues générables par chacun des demi-additionneurs)  :

Additionneur parallèle à propagation de retenue

Il est envisageable de chaîner plusieurs additionneurs un bit pour en fabriquer un capable de traiter des mots de longueurs arbitraires :

L'inconvénient de ce circuit est sa lenteur car il dépend du temps de propagation de la retenue de module en module. Cette conception ne peut être choisie pour des circuits dépassant quelques bits, à moins de n'avoir aucune contrainte de temps.

Additionneur parallèle à retenue anticipée

Dans ce qui suit on note A et B le cumulande et le cumulateur. R est la retenue. X_indice indique le bit auquel on s'intéresse, 0 étant l'indice de poids le plus faible. La fonction logique OU est notée «+». La fonction logique ET est notée «.» ou n'est pas notée du tout (ainsi A B est l'équivalent de A. B ou A ET B).

Dans un premier temps on constate que le calcul de la retenue est particulièrement faisable théoriquement : dans la pratique il nécessite énormément trop de portes logiques. Pour le second additionneur, la retenue (en entrée) est égale à :

R₁ = (A₀. B₀) + (A₀. R₀) + (B₀. R₀) (1)

Pour le troisième additionneur, la retenue est égale à :

R₂ = (A₁. B₁) + (A₁. R₁) + (B₁. R₁) (2)

et ainsi de suite. On peut substituer R₁ dans (2) par sa valeur (1) . On voit immédiatement que le résultat est une formule particulièrement longue rendant cette technique complètement impraticable pour un additionneur de , par exemple, 16 bits.

Il faut par conséquent trouver un compromis entre vitesse et complexité du circuit chargé de calculer les retenues. Cela peut se faire par l'utilisation de deux valeurs intermédiaires : la retenue propagée et la retenue générée. Appelées p et g, elles sont définies ainsi :

• p, la retenue propagée sera égale à 1 si l'un des bits du cumulande ou cumulateur est à 1 : p_i = A_i OU_exclusif B_i.
• g, la retenue générée sera égale à 1 si à la fois le bit en question du cumulande et du cumulateur sont à 1 : g_i = A_i ET B_i.

Comme en base 10, si les deux chiffres à additionner forment un résultat supérieur à 9, alors une retenue est générée, et si deux chiffres forment le total 9, alors la retenue (peut-être issue de la colonne de chiffres précédente) sera propagée. On peut aisément modifier un additionneur complet pour en extraire ces deux nouveaux signaux.

Par la suite, on peut constater que la retenue du second additionneur peut être aisément calculée : en effet, à partir du premier additionneur et de ses sorties p et g, la retenue sera à 1 si g est à 1 (elle est générée), ou bien p est à 1 en même temps qu'on à déjà une retenue. C'est-à-dire : R₁ = g₀ OU (p₀ ET R₀), et ainsi de suite :

• R₂ = g₁ + (p₁. g₀) + (p₁. p₀. r₀)
• R₃ = g₂ + (p₂. g₁) + (p₂. p₁. g₀) + (p₂. p₁. p₀. r₀)
• R₄ = g₃ + (p₃. g₂) + (p₃. p₂. g₁) + (p₃. p₂. p₁. g₀) + (p₃. p₂. p₁. p₀. r₀)

On peut étendre ce principe à des additionneurs N bits, chacun composé de N additionneurs 1 bit et son unité de calcul anticipé de la retenue. A titre d'exemple, un bloc de base avec N = 4 peut être représenté schématiquement comme ceci :

Ces blocs sont à leur tour cascadables pour former un additionneur 16 bits :

Additionneur série

Les premiers ordinateurs utilisaient un additionneur série. Ce circuit n'est plus combinatoire mais capable de produire un bit du résultat à chaque impulsion de l'horloge qui le cadence. Un tel circuit est extrêmement simple :

Ce circuit est constitué de trois parties :

1. la porte ET commandée par l'entrée L qui sert à spécifier l'arrivée du premier bit de poids faible dans le circuit ;
2. une bascule de type D pour mémoriser la valeur de la retenue à l'étape précédente ;
3. un additionneur complet 1 bit dont les entrées X et Y sont les nombres à ajouter et dont l'entrée Retenue est reliée à la sortie de la bascule D.

Le chronogramme indique quoique 5 (X) + 7 (Y) = 12 (S) (101 + 111 = 0011 en binaire, en lisant de droite à gauche). L'état des retenues C_o et C_oo est indiqué de manière purement informative.

Optimisation des additionneurs

Les additionneurs sont au cœur des unités arithmétique et logique des processeurs. Des techniques particulièrement spécifiques sont mises en œuvre pour additionner le plus vite envisageable, le plus fréquemment en utilisant des techniques complexes de prédiction de la retenue (cf. références). Par exemple on peut détecter des blocs (série de bits consécutifs) ne générant pas de retenue, et par conséquent particulièrement rapides à additionner. On peut aussi calculer deux résultats indépendamment et en parallèle, l'un avec une retenue, l'autre sans, et ensuite choisir le bon (via un multiplexeur).

Voir aussi

Liens externes

• Génération à la volée du schéma d'un additionneur à retenue anticipée, à partir de deux opérandes.
• Simulateurs de différents circuits additionneurs, du plus simple au plus complexe, en applet Java.
• [pdf] High-speed binary adder, H. Ling, 1981.
• Définition d'un additionneur à retenue anticipée en langage VHDL.

Ce texte est issu de l'encyclopédie Wikipedia. Vous pouvez consulter sa version originale dans cette encyclopédie à l'adresse http://fr.wikipedia.org/wiki/Additionneur.
Voir la liste des contributeurs.
La version présentée ici à été extraite depuis cette source le 07/04/2010.
Ce texte est disponible sous les termes de la licence de documentation libre GNU (GFDL).
La liste des définitions proposées en tête de page est une sélection parmi les résultats obtenus à l'aide de la commande "define:" de Google.
Cette page fait partie du projet Wikibis.