Fonctionnement d'un ordinateur/Les circuits de comparaison

Les comparateurs sont des circuits qui permettent de comparer deux nombres, à savoir s'ils sont égaux, si l'un est supérieur à l'autre, ou inférieur, ou différent, etc. Dans ce qui va suivre, nous allons voir quatre types de comparateurs. Le premier type de circuit vérifie si un nombre est nul ou différent de zéro. Le second vérifie si deux nombres sont égaux, tandis que le troisième vérifie s'ils sont différent. Enfin, le quatrième vérifie si un nombre est supérieur ou inférieur à un autre. Il faut signaler que nous avons déjà vu comment vérifier qu'un nombre est égal à une constante dans le chapitre sur les circuits combinatoires, aussi nous ne reviendrons pas dessus.

Le comparateur de 1 bit[modifier | modifier le wikicode]

Maintenant, nous allons voir comment vérifier si deux bits sont égaux/différents, si le premier est inférieur au second ou supérieur. Le but est de créer un circuit qui prend en entrée deux bits A et B, et fournit en sortie quatre bits :

$A>B$ qui vaut 1 si le bit A est supérieur à B et 0 sinon ;
$A<B$ qui vaut 1 si le bit A est inférieur à B et 0 sinon ;
$A=B$ qui vaut 1 si le bit A est égal à B et 0 sinon ;
$A\neq B$ qui vaut 1 si le bit A est différent de B et 0 sinon.

Peut-être avez-vous remarqué l'absence de sortie qui indique si $A\leq B$ ou $A\geq B$ . Mais ces deux sorties peuvent se calculer en combinant la sortie $A=B$ avec les sorties $A>B$ et $A<B$ . De plu, vous pouvez remarquer que les deux dernières entrées sont l'inverse l'une de l'autre, ce qui n'est pas le cas des deux premières. Nous allons d'abord voir comment calculer les deux premières sorties, à savoir $A>B$ et $A<B$ . La raison à cela est que les deux autres sorties peuvent se calculer à partir de celles-ci.

Le comparateur de supériorité/infériorité stricte[modifier | modifier le wikicode]

En premier lieu, nous allons voir comment vérifier qu'un bit A est strictement supérieur ou inférieur à un bit B. Pour cela, le mieux est d'établir la table de vérité des deux comparaisons. La table de vérité est la suivante :

Entrée A	Entrée B	Sortie <	Sortie >
0	0	0	0
0	1	1	0
1	0	0	1
1	1	0	0

On obtient les équations suivantes :

Sortie > : ${\overline {a}}.b$
Sortie < : $a.{\overline {b}}$

On voit que quand les deux bits sont égaux, alors les deux sorties sont à zéro.

Le comparateur d'inégalité 1 bit[modifier | modifier le wikicode]

La seconde étape est de concevoir un petit circuit qui vérifie si deux bits sont différents, inégaux. Pour cela, on peut combiner les deux signaux précédents. En effet, on sait que si A et B sont différents, alors soit A>B, soit A<B. En conséquence, on a juste à combiner les deux signaux vus précédemment avec une porte OU.

Ce circuit devrait vous dire quelque chose. Pour ceux qui n'ont pas déjà remarqué, le mieux est d'établir la table de vérité du circuit, ce qui donne :

Entrée 1	Entrée 2	Sortie
0	0	0
0	1	1
1	0	1
1	1	0

On voit rapidement qu'il s'agit d'une porte XOR.

Le comparateur d'égalité 1 bit[modifier | modifier le wikicode]

Enfin, nous allons concevoir un petit circuit qui vérifie si deux bits sont égaux. La logique veut que l'égalité est l'inverse de l'inégalité, ce qui fait qu'il suffirait d'ajouter une porte NON en sortie du circuit. Le circuit précédent est alors facile à adapter : il suffit de remplacer la porte OU par une porte NOR. Et si le comparateur d'inégalité 1 bit était une porte XOR, on devine rapidement que le comparateur d'égalité 1 bit est quant à lui une porte NXOR. Ce qui se vérifie quand on regarde la table de vérité du comparateur :

A	B	A=B
0	0	1
0	1	0
1	0	0
1	1	1

L'interprétation de ce circuit est assez simple. Par définition, deux nombres sont égaux si les deux conditions $A>B$ et $A<B$ sont fausses. C’est pour cela que le circuit calcule d'abord les deux signaux $A>B$ et $A<B$ , puis qu'il les combine avec une porte NOR.

Le circuit complet[modifier | modifier le wikicode]

Fort de ces résultats, nous pouvons fabriquer un comparateur de 1 bit. Celui-ci prend deux bits en entrée, et fournit trois bits en sortie : un pour l'égalité, un autre pour la supériorité et un autre pour l'infériorité. Voici le circuit au complet (sans le bit de différence). On pourrait rajouter le bit de différence assez simplement, en ajoutant une porte OU en sortie des signaux $A>B$ et $A<B$ , mais nous le ferons pas pour ne pas surcharger inutilement les schémas.

Il est aussi possible de reformuler le schéma précédent pour supprimer une redondance invisible dans le circuit, au niveau de la porte NXOR qui calcule le bit d'égalité. À la place, il est possible de prendre les signaux $A>B$ et $A<B$ et de les combiner avec une porte NOR. Ou encore mieux : on utilise une porte OU et une porte NON, la sortie de la porte OU donnant directement le bit d'inégalité, celle de la porte NON donnant le bit d'égalité. Cela économise quelques transistors, mais rallonge un petit peu le circuit.

Les comparateurs pour entiers non-signés[modifier | modifier le wikicode]

Dans ce qui va suivre, nous allons créer un circuit qui est capable de vérifier l'égalité, la supériorité ou l'infériorité de deux nombres. Celui-ci prend deux nombres en entrée, et fournit trois bits : un pour l'égalité des deux nombres, un autre pour préciser que le premier est supérieur au second, et un autre pour préciser que le premier est inférieur au second. Il existe deux méthodes pour créer des comparateurs : une basée sur une soustraction, l'autre sur des comparaisons bit par bit. Dans cette section, nous allons nous concentrer sur le second type, les comparateurs basés sur une soustraction étant vu à la fin du chapitre. De plus, nous allons nous concentrer sur des comparateurs qui testent deux opérandes non-signées (nulles ou positives, mais pas négatives).

Les comparateurs sériels[modifier | modifier le wikicode]

La manière la plus simple est de faire la comparaison bit par bit avec un circuit séquentiel. Pour cela, on doit utiliser deux registres à décalage pour les opérandes. Les bits sortants à chaque cycle sont les bits de même poids et ils sont comparés par un comparateur 1 bit. Le résultat de la comparaison est mémorisé dans une bascule de quelques bits, qui mémorise le résultat temporaire de la comparaison. A chaque cycle, le comparateur de 1 bit fournit son résultat, qu'il faut combiner avec celui dans la bascule, ce qui permet de combiner les résultats temporaire avec les résultats de la colonne en cours de traitement. Et c'est une chose que le comparateur 1 bit précédent ne sait pas faire. Pour cela, nous allons devoir créer un circuit, nommé le comparateur complet.

Dans ce qui va suivre, la comparaison va s'effectuer en partant du bit de poids faible et se fera de gauche à droite, chose qui a son importance pour ce qui va suivre. Quel que soit le sens de parcours, on sait comment calculer le bit d'égalité : celui-ci est égal à un ET entre le bit d'égalité fournit en entrée, et le résultat de la comparaison A = B. Pour les bits de supériorité et d'infériorité, les choses changent : la colonne en cours de traitement supplante l'autre colonne. Dit autrement, les bits de poids fort donnent le résultat de la comparaison. Pour déterminer comment calculer ces bits, le mieux est encore d'établir la table de vérité du circuit pour ces deux bits. Nous allons postuler que les bits A > B et A < B ne peuvent être à 1 en même temps : il s'agit de supériorité et d'infériorité stricte. Voici la table de vérité :

Entrée >	Entrée <	A > B	A < B	Sortie >	Sortie <
0	0	0	0	0	0
0	0	0	1	0	1
0	0	1	0	1	0
0	0	1	1	X	X
0	1	0	0	0	1
0	1	0	1	0	1
0	1	1	0	1	0
0	1	1	1	X	X
1	0	0	0	1	0
1	0	0	1	0	1
1	0	1	0	1	0
1	0	1	1	X	X
1	1	0	0	X	X
1	1	0	1	X	X
1	1	1	0	X	X
1	1	1	1	X	X

Les équations logiques obtenues sont donc les suivantes :

Sortie (=) : $E(=).(A=B)$
Sortie (>) : $(A>B)+\left[E(>).{\overline {(A<B)}}\right]$
Sortie (<) : $(A<B)+\left[E(<).{\overline {(A>B)}}\right]$

Il est possible de simplifier le circuit de manière à ce qu'il ne fasse pas la comparaison d'égalité, qui se déduit des deux autres comparaisons. Si les deux sorties < et > sont à 0, alors les deux bits sont égaux. Si on avait utilisé des sorties >= et <=, il aurait fallu que les deux bits soient à 1 pour montrer une égalité.

On peut aussi fabriquer un comparateur d'égalité sériel. Nous aurons à utiliser ce circuit plusieurs fois dans la suite du cours, notamment dans le chapitre sur les mémoires associatives. Le circuit est strictement identique au précédent, si ce n'est que l'on retire les portes pour les comparaisons non-voulues, et que la bascule n'a besoin que de mémoriser un seul bit. La comparaison d'égalité est réalisée par une porte NXOR, et le résultat est combiné avec le contenu de la bascule avec une porte ET.

Les comparateurs parallèles[modifier | modifier le wikicode]

Il est possible de dérouler le circuit précédent, de la même manière que l'on peut dérouler un additionneur sériel pour obtenir un additionneur à propagation de retenue. L'idée est de traiter les bits les uns après les autres, chacun avec un comparateur complet par colonne. Les comparateurs sont connectés de manière à traiter les opérandes dans un sens bien précis : soit des bits de poids faible vers ceux de poids fort, soit dans le sens inverse. Tout dépend du comparateur. Un tel circuit n'a pas l'air très optimisé et ne paye pas de mine, mais il a déjà été utilisé dans des processeurs commerciaux. Par exemple, c'est ce circuit qui était utilisé dans le processeur HP Nanoprocessor, un des tout premiers microprocesseurs.

Un inconvénient de cette méthode est que le résultat est lent à calculer, car on doit traiter les opérande colonne par colonne, comme pour les additionneurs. Sur ces derniers, il fallait propager une retenue de colonne en colonne, mais diverses optimisations permettaient d'optimiser le tout, soit en accélérant la propagation de la retenue, soit en l’anticipant, soit en faisant les calculs de retenue en parallèle, etc. Pour les comparateurs, ce n'est pas une retenue qui se déplace, mais des résultats temporaires. Sauf qu'il n'y a pas de moyen simple pour faire comme avec les additionneurs/soustracteurs et d'anticiper ou calculer en parallèle ces résultats temporaires.

Il est cependant possible de faire des calculs en parallèle, mais en réduisant fortement les fonctionnalités du circuit. Notamment, les circuits qui vérifient si deux nombres sont égaux ou différents sont beaucoup plus simples que les autres. Ils sont juste composés de deux couches de portes logiques, et non de comparateurs enchainés en série. C'est la raison pour laquelle nous allons voir ces deux types de comparateurs ensemble. Les deux sont basés sur le même modèle et ont une structure similaire. Ils sont composés d'une couche de comparateurs de 1 bits, suivi par une porte logique à plusieurs entrées. La couche de comparateur 1 bits vérifie si les bits de même poids des deux opérandes sont différents ou identiques. La porte logique combine les résultats de ces comparaisons individuelles et en déduit le bit de sortie. Nous allons aussi voir un autre comparateur parallèle très spécialisé, qui vérifie si l'opérande d'entrée vaut zéro.

Le comparateur d'égalité[modifier | modifier le wikicode]

Pour des entiers non-signés, ainsi que pour les entiers en complément à deux, l'égalité de deux nombres se détermine assez facilement. Deux nombres sont égaux s'ils ont la même représentation en binaire, ils sont différents sinon. Notons que cela ne marche pas dans les autres représentations pour les entiers signés. La raison est la présence de deux zéros : un zéro positif et un zéro négatif. Les circuits de comparaison d'égalité et de différence sont donc légèrement différents suivant la représentation des nombres utilisée. La règle qui veut que deux nombres soient égaux s'ils ont la même représentation en binaire, s'ils sont codés par la même suite de bit, implique qu'un nombre n'est codé que d'une seule manière, qu'il n'y a pas de redondance. C'est le cas en binaire non-signé et en complément à deux, qui arrivent à coder un maximum de valeurs pour un nombre de bits déterminé, ce qui fait qu'elles ont le bon gout de ne pas avoir de redondance. Mais d'autres représentations volontairement redondantes violent cette règle.

Le circuit qui vérifie si deux nombres sont égaux est très simple : il prend les bits de même poids des deux opérandes (ceux à la même position, sur la même colonne) et vérifie qu'ils sont égaux. Le circuit est donc composé d'une première couche de portes NXOR qui vérifie l'égalité des paires de bits, suivie par une porte logique qui combine les résultats des porte NXOR. La logique dit que la sortie vaut 1 si tous les bits de sortie des NXOR valent 1. La seconde couche est donc, par définition, une porte ET à plusieurs entrées.

Une autre manière de concevoir ce circuit inverse la logique précédente. Au lieu de tester si les paires de bits sont égales, on va tester si elles sont différentes. On teste les bits de même poids et la moindre différence entre deux bits entraîne l'inégalité. Pour tester la différence de deux bits, une porte XOR suffit. Pour combiner les résultats des portes XOR, on utilise une porte NOR. En effet, le fait qu'une seule paire soit différente suffit à rendre les deux nombres inégaux. Dit autrement, si une porte XOR sort un 1, alors la sortie du comparateur d'égalité doit être de 0 : c'est le fonctionnement d'une porte NOR.

Notons qu'on peut passer d'un circuit à l'autre en utilisant la loi de de Morgan

Le circuit qui vérifie si deux nombres sont différents peut être construit à partir du circuit précédent et d'inverser son résultat avec une porte NON. Le résultat est que l'on change la porte ET finale du premier circuit par une porte NAND, la porte NOR du second circuit par une porte OU.

Le comparateur avec zéro, un circuit simple utilisé pour fabriquer d'autres comparateurs[modifier | modifier le wikicode]

Le circuit que nous allons maintenant aborder ne compare pas deux nombres, mais vérifie si l'opérande d'entrée est nulle. Il fonctionne sur un principe simple : un nombre est nul si tous ses bits valent 0. Du moins, c'est le cas pour les entiers non-signés ou en complément à deux.

La solution la plus simple pour créer ce circuit est d'utiliser une porte NOR à plusieurs entrées. Par définition, la sortie d'une NOR vaut zéro si un seul bit de l'entrée est à 1 et 0 sinon, ce qui répond au cahier des charges.

Il existe une autre possibilité strictement équivalente, qui inverse l'entrée avant de vérifier si tous les bits valent 1. Si l'entrée est nulle, tous les bits inversés valent tous 1, alors qu'une entrée non-nulle donnera au moins un bit à 0. Le circuit est donc conçu avec des portes NON pour inverser tous les bits, suivies d'une porte ET à plusieurs entrées qui vérifie si tous les bits sont à 1.

Notons qu'en peut passer d'un circuit à l'autre en utilisant les lois de de Morgan.

Le circuit précédent marche parfaitement pour les entiers non-signés, mais aussi pour ceux codés en complément à deux.

Combiner plusieurs comparateurs[modifier | modifier le wikicode]

Il est possible de combiner plusieurs comparateurs simples pour traiter des nombres assez longs. Par exemple, on peut enchainer 2 comparateurs série 4 bits pour obtenir un comparateur série 8 bits. Pour cela, il y a deux grandes solutions : soit on enchaine les comparateurs en série, soit on les fait travailler en parallèle.

La première méthode place les comparateurs en série, c'est à dire que le second comparateur prend le résultat du premier pour faire son travail. Le second comparateur doit avoir trois entrées nommées <, > et =, qui fournissent le résultat du comparateur précédent. On peut faire la même chose avec plus de 2 comparateurs, l'essentiel étant que les comparateurs se suivent.

Une autre solution est de faire les comparaisons en parallèle et de combiner les bits de résultats des différents comparateurs avec un dernier comparateur. Le calcul de la comparaison est alors légèrement plus rapide qu'avec les autres méthodes, mais le circuit devient plus compliqué à concevoir.

Les comparateurs pour nombres signés[modifier | modifier le wikicode]

Comparer deux nombres signés n'est pas la même chose que comparer deux nombres non-signés. Autant la comparaison d'égalité et de différence est strictement identique, autant les comparaisons de supériorité et d'infériorité ne le sont pas. Les comparateurs pour nombres signés sont naturellement différents des comparateurs vus précédemment. On verra plus tard qu'il en est de même avec les comparateurs pour nombres flottants. Il fut aussi faire attention : la comparaison ne s'effectue pas de la même manière selon que les nombres à comparer sont codés en signe-magnitude, en complément à deux, ou dans une autre représentation. Dans ce qui va suivre, nous allons aborder la comparaison en signe-magnitude et en complément à deux, mais pas les autres représentations.

Le comparateur signe-magnitude[modifier | modifier le wikicode]

Un comparateur en signe-magnitude n'est pas trop différent d'un comparateur normal. Effectuer une comparaison entre deux nombres en signe-magnitude demande de comparer les valeurs absolues, ainsi que comparer les signes. Une fois cela fait, il faut combiner les résultats de ces deux comparaisons en un seul résultat.

Comment comparer les signes ?[modifier | modifier le wikicode]

Comparer les signes est relativement simple : le circuit n'ayant que deux bits à comparer, celui-ci est naturellement simple à concevoir. On pourrait penser que l'on peut réutiliser le comparateur 1 bit vu précédemment dans ce chapitre, mais cela ne marcherait pas ! En effet, un nombre positif a un bit de signe nul alors qu'un nombre négatif a un bit de signe égal à 1 : les résultats sont inversés. Un bon moyen de s'en rendre compte est d'écrire la table de vérité de ce circuit, selon les signes des nombres à comparer. Nous allons supposer que ces deux nombres sont appelés A et B.

Bit de signe de A	Bit de signe de B	Sortie =	Sortie <	Sortie >
0 (+)	0 (+)	1	0	0
1 (-)	0 (+)	0	0	1
0 (+)	1 (-)	0	1	0
1 (-)	1 (-)	1	0	0

On obtient les équations suivantes :

Sortie = : ${\overline {a\oplus b}}$
Sortie < : ${\overline {a}}.b$
Sortie > : $a.{\overline {b}}$

On peut remarquer que si le bit d'égalité est identique au comparateur 1 bit vu plus haut, les bits de supériorité et l'infériorité sont inversés, échangés. On peut donc réutiliser le comparateur à 1 bit, mais en intervertissant les deux sorties de supériorité et d'infériorité.

Comment combiner les résultats ?[modifier | modifier le wikicode]

Une fois qu'on a le résultat de la comparaison des signes, on doit combiner ce résultat avec le résultat de la comparaison des valeurs absolues. Pour cela, on doit rajouter un circuit à la suite des deux comparateurs. On pourrait penser qu'il suffit d'établir la table de vérité de ce comparateur, mais il faut faire attention au cas où les deux opérandes sont nulles : dans ce cas, peut importe les signes, les deux opérandes sont égales. Pour le moment, mettons ce fait de côté et établissons la table de vérité du circuit. Dans tous les cas, la comparaison des bits de signe prend le pas sur la comparaison des valeurs absolues. Par exemple, 2 est supérieur à -255, bien que ce ne soit pas le cas pour les valeurs absolues. Ce fait n'est que l'expression du fait qu'un nombre positif est systématiquement supérieur à un négatif, de même qu'un négatif est systématiquement inférieur à un positif. Ce n'est que quand les deux bits de signes sont égaux que la comparaison des valeurs absolue est à prendre en compte. Cela devrait donner les équations suivantes. On note les résultats de la comparaison des bits de signe comme suit : $=_{s},>_{s},<_{s}$ , alors que les résultats de la comparaison des valeurs absolues sont notés : $=_{m},>_{m},<_{m}$ .

$=_{s}.=_{m}$ pour le résultat d'égalité ;
$<_{s}+(=_{s}.<_{m})$ pour l’infériorité ;
$>_{s}+(=_{s}.>_{m})$ pour la supériorité.

Néanmoins, il faut prendre en compte le cas où les deux opérandes sont nulles, ce qui complique un petit peu les équations Pour cela, il fat rajouter une sortie au comparateur de valeurs absolues, qui indique si les deux nombres valent tous deux zéro. Notons cette sortie $z_{m}$ . Les équations deviennent :

$(=_{s}.=_{m})+z_{m}$ pour l'égalité ;
$(<_{s}.{\overline {z_{m}}})+(=_{s}.<_{m})$ pour l’infériorité ;
$(>_{s}.{\overline {z_{m}}})+(=_{s}.>_{m})$ pour la supériorité.

Les comparateurs en complément à un et en complément à deux[modifier | modifier le wikicode]

La comparaison en complément à un ou à deux peut s'implémenter comme en signe-magnitude : on compare les valeurs absolues, puis les signes, avant de déterminer le résultat. Reste à calculer les valeurs absolues, ce qui est loin d'être simple.

En complément à 1, il suffit d'inverser tous les bits si le bit de signe est de 1. E, complément à deux, il faut faire pareil, puis incrémenter le résultat.

Les comparateurs basés sur un soustracteur[modifier | modifier le wikicode]

Les comparateurs présents dans les ordinateurs modernes fonctionnent sur un principe totalement différents. Ils soustraient les deux opérandes et étudient le résultat. Le résultat peut avoir quatre propriétés intéressantes lors d'une comparaison : si le résultat est nul ou non, son bit de signe, s'il génère une retenue sortante (débordement entier non-signé) et s'il génère un débordement entier en complément à deux. Ces quatre propriétés sont extraites du résultat, et empaquetées dans 4 bits, appelés les 4 bits intermédiaires. En effectuant quelques opérations sur ces 4 bits intermédiaires, on peut déterminer toutes les conditions possibles : si la première opérande est supérieure à l'autre, si elle est égale, si elle est supérieure ou égale, etc. Le circuit est donc composé de trois sous-circuits : le soustracteur, un circuit qui calcule les 4 bits intermédiaires, puis un autre qui calcule la ou les conditions voulues.

L'avantage de ce circuit est qu'il est plus rapide que les autres comparateurs. Rappelons que les comparateurs parallèles testent les opérandes colonne par colonne, et qu'on a pas de moyens simples pour éviter cela. Avec un soustracteur, on peut utiliser des techniques d'anticipation de retenue pour accélérer les calculs. Les calculs sont donc faits en parallèle, et non colonne par colonne, ce qui est beaucoup plus rapide, surtout quand les opérandes sont un peu longues. Ce qui fait que tous les processeurs modernes utilisent le circuit suivant pour faire des comparaisons. Il faut dire qu'il n'a que des avantages : plus rapide, il utilise un peu plus de portes logiques mais cela reste parfaitement supportable, il permet de générer des bits intermédiaires utiles que les autres comparateurs peinent à fournir, etc. De plus, il peut comparer aussi bien des entiers codés en complément à deux que des entiers non-signés, là où les comparateurs précédents ne le permettaient pas.

La génération des conditions[modifier | modifier le wikicode]

La génération des 4 bits intermédiaire est simple et demande peu de calculs. Déterminer si le résultat est nul demande juste d'utiliser un comparateur avec zéro, qui prend en entrée le résultat de la soustraction. La génération des bits de débordement a été vue dans le chapitre sur les circuits d'addition et de soustraction, aussi pas besoin de revenir dessus. Par contre, il est intéressant de voir comment les 4 bits intermédiaires sont utilisés pour générer les conditions voulues.

Déjà, les deux opérandes sont égales si le résultat de leur soustraction est nul, et elles sont différentes sinon. Le bit qui indique si le résultat est nul ou non indique si les deux opérandes ont égales ou différentes. Cela fait déjà deux conditions de faites. De plus, l'égalité et la différence se calculent de la même manière en complément à deux et avec des entiers non-signés.

Pour ce qui est de savoir quelle opérande est supérieure ou inférieure à l'autre, cela dépend de si on analyse deux entiers non-signés ou deux entiers en complément à deux.

Avec des entiers non-signés, il faut regarder si la soustraction génère une retenue sortante, un débordement entier non-signé. Si c'est le cas, alors la première opérande est inférieure à la seconde. Si ce n'est pas le cas, alors la première opérande est supérieure ou égale à la seconde.
Pour la comparaison en complément à deux on se dit intuitivement qu'il faut regarder le signe du résultat. L'intuition nous dit que la première opérande est inférieure à l'autre si le résultat est négatif, qu'elle est supérieure ou nulle s'il est positif. Sauf que cela ne marche pas exactement comme cela : il faut aussi regarder si le calcul entraine un débordement d'entier en complément à deux. La règle est que le résultat est négatif si on a un débordement d'entier en complément à deux OU que le bit de signe est à 1. Une seule des deux conditions doit être respectée : le résultat est positif sinon. On doit donc faire un XOR entre le bit de débordement et le bit de signe. Le bit sortant de la porte XOR indique que le résultat de la soustraction est négatif, et donc que la première opérande est inférieure à la seconde.

Avec ces deux informations, égalité et supériorité, on peut déterminer toutes les autres. Dans ce qui va suivre, nous allons partir du principe que le soustracteur est suivi par des circuits qui calculent les bits suivants :

un bit S qui n'est autre que le bit de signe en complément à deux ;
un bit Z qui indique si le résultat est nul ou non (1 pour un résultat nul, 0 sinon) ;
un bit C qui n'est autre que la retenue sortante (1 pour un débordement d'entier non-signé, 0 sinon) ;
un bit D qui indique un débordement d'entier signé (1 pour un débordement d'entier signé, 0 sinon).

Condition testée	Calcul
A == B	Z = 1
A != B	Z = 0
Opérandes non-signées
A < B	C = 1
A >= B	C = 0
A <= B	C OU Z = 1
A > B	C ET Z = 0
Opérandes en complément à deux
A < B	S XOR D = 1
A >= B	S XOR D = 0
A <= B	(S XOR D) OU Z = 1
A > B	(S XOR D) ET Z = 0

Le comparateur-soustracteur total[modifier | modifier le wikicode]

Il est possible de raffiner ce circuit, de manière à pouvoir choisir la condition en sortie du circuit. L'idée est que le circuit possède une seule sortie, sur laquelle on a le résultat de la condition choisie. Le circuit possède une entrée sur laquelle on envoie un nombre, qui permet de choisir la condition à tester. Par exemple, on peut vouloir vérifier si deux nombres sont égaux. Dans ce cas, on configure le circuit en envoyant sur l'entrée de sélection le nombre qui correspond au test d'égalité. Le circuit fait alors le test, et fournit le résultat sur la sortie de 1 bit. Ce circuit se construit simplement à partir du circuit précédent, en ajoutant un multiplexeur. Concrètement, on prend un soustracteur, on ajoute des circuits pour calculer les bits intermédiaires, puis on ajoute des portes pour calculer les différentes conditions, et enfin, on ajoute un multiplexeur.

Nous réutiliserons ce circuit bien plus tard dans ce cours, dans les chapitres sur les branchements. Mais ne vous inquiétez pas, dans ces chapitres, nous ferons des rappels sur les bits intermédiaires, la manière dont sont calculées les conditions et globalement sur tout ce qui a été dit dans cette section. Pas besoin de mémoriser par coeur les équations de la section précédente, tout ce qui compte est que vous ayez retenu le principe général.

◄ Retour vers « Les circuits de calcul flottant »

Sommaire du livre

Continuer vers « Les circuits de correction d'erreur » ►