Fonctionnement d'un ordinateur/Les circuits synchrones

Un livre de Wikilivres.
Aller à : navigation, rechercher

Maintenant que l'on sait créer des registres, nous sommes proches de pouvoir créer n'importe quel circuit séquentiel. Pour l'instant, on peut créer des circuits séquentiels simples, qui ne contiennent qu'un seul registre. Mais la majorité des circuits séquentiels présents dans un ordinateur possèdent plusieurs registres. Si on utilise plusieurs registres, c'est avant tout pour mémoriser des informations différentes : on pourrait les mémoriser dans un seul registre, mais utiliser un registre par nombre à mémoriser est de loin la méthode la plus intuitive. Sauf qu'un léger détail vient mettre son grain de sel : tous les circuits combinatoires, qui mettent à jour les registres, ne vont pas à la même vitesse ! En conséquence, les registres d'un composant ne sont pas mis à jour en même temps, ce qui pose quelques problèmes relativement fâcheux si aucune mesure n'est prise.

Temps de propagation[modifier | modifier le wikicode]

Pour commencer, il nous faut expliquer pourquoi tous les circuits combinatoires ne vont pas à la même vitesse. Tout circuit, quel qu'il soit, va mettre un petit peu de temps avant de réagir. Ce temps mis par le circuit pour propager un changement sur les entrées vers la sortie s'appelle le temps de propagation. Pour faire simple, c'est le temps que met un circuit à faire ce qu'on lui demande : plus ce temps de propagation est élevé, plus le circuit est lent. Ce temps de propagation dépend de pas mal de paramètres, aussi je ne vais citer que les trois principaux.

Fanout des portes logiques[modifier | modifier le wikicode]

Le premier facteur que nous allons aborder est le nombre de portes logiques reliées sur un même fil. Plus on connecte de portes logiques sur un fil, plus il faudra du temps pour que la tension à l'entrée de ces portes passe de 1 à 0 (ou inversement).

Temps de latence des fils[modifier | modifier le wikicode]

Ensuite, vient le temps de propagation dans les fils, celui mis par notre tension pour se propager dans les fils qui relient les portes logiques entre elles. Ce temps perdu dans les fils devient de plus en plus important au cours du temps, les transistors et portes logiques devenant de plus en plus rapides à force des les miniaturiser. Par exemple, si vous comptez créer un circuit avec des entrées de 256 à 512 bits, il vaut mieux le modifier pour minimiser le temps perdu dans les interconnexions que de diminuer le chemin critique.

Chemin critique[modifier | modifier le wikicode]

Mais le plus important de ces paramètres est ce qu'on appelle le chemin critique, le nombre maximal de portes logiques entre une entrée et une sortie de notre circuit. Pour donner un exemple, nous allons prendre le schéma suivant. Pour ce circuit, le chemin critique est dessiné en rouge. En suivant ce chemin, on va traverser trois portes logiques, contre deux ou une dans les autres chemins.

Délai de propagation dans un circuit simple.

Le temps de propagation total, lié au chemin critique, se calcule à partie de plusieurs paramètres. Premièrement, il faut déterminer quel est le temps de propagation pour chaque porte logique du circuit. En effet, chaque porte logique met un certain temps avant de fournir son résultat en sortie : quand les entrées sont modifiées, il faut un peu de temps pour que sa sortie change. Ensuite, pour chaque porte, il faut ajouter le temps de propagation des portes qui précédent. Si plusieurs portes sont reliées sur les entrées, on prend le temps le plus élevé. Enfin, il faut identifier le chemin critique, le plus long : le temps de propagation de ce chemin est le temps qui donne le tempo maximal du circuit.

Conséquences[modifier | modifier le wikicode]

Ce temps de propagation doit être pris en compte quand on crée un circuit séquentiel : sans ça on ne sait pas quand mettre à jour la mémoire dans le circuit. Si on le fait trop tôt, le circuit combinatoire peut sauter des états : il se peut parfaitement qu'on change le bit placé sur l'entrée avant qu'il soit mémorisé. De plus, les différents circuits d'un composant électronique n'ont pas tous le même temps de propagation, et ceux-ci vont fonctionner à des vitesses différentes. Si l'on ne fait rien, on peut se retrouver avec des dysfonctionnements : par exemple, un circuit lent peut rater deux ou trois nombres envoyées par un composant un peu trop rapide.

Circuits synchrones et asynchones[modifier | modifier le wikicode]

Pour éviter les ennuis dus à l'existence de ce temps de propagation, il existe deux grandes solutions, qui permettent de faire la différence entre circuits asynchrones et synchrones. Les circuits asynchrones préviennent la mémoire quand ils veulent la mettre à jour. Quand le circuit combinatoire et la mémoire sont tous les deux prêts, on autorise l'écriture dans la mémoire. Mais ce n'est pas cette solution qui est utilisée dans les circuits de nos ordinateurs, qui sont des circuits synchrones. Dans les circuits synchrones, les registres sont tous mis à jour en même temps. On peut remarquer que c'est quelque chose d'analogue à ce qu'on trouve sur les registres : si toutes les bascules d'un registre doivent être mises à jour en même temps, tous les registres d'un circuit séquentiel doivent être mis à jour en même temps. La solution est donc similaire à celle utilisée sur les registres : on commande la mise à jour des registres par un signal d'autorisation d'écriture, qui est transmis à tous les registres en même temps.

Les circuits synchrones[modifier | modifier le wikicode]

Généralement, ces circuits mettent à jour leurs mémoires à intervalles réguliers. La durée entre deux mises à jour est constante et doit être plus grande que le pire temps de propagation possible du circuit : on se cale donc sur le circuit combinatoire le plus lent. Les concepteurs d'un circuit doivent estimer le pire temps de propagation possible pour le circuit et ajouter une marge de sûreté. Pour mettre à jour nos circuits à intervalles réguliers, le signal d'autorisation d'écriture est une tension qui varie de façon cyclique : on parle alors de signal d'horloge. Le temps que met la tension pour effectuer un cycle est ce qu'on appelle la période. Le nombre de périodes par seconde est appelé la fréquence. Elle se mesure en hertz. On voit sur ce schéma que la tension ne peut pas varier instantanément : elle met un certain temps pour passer de 0 à 1 et de 1 à 0. On appelle cela un front. La passage de 0 à 1 est appelé un front montant et le passage de 1 à 0 un front descendant.

Fréquence et période.

En faisant cela, notre circuit logique mettra ses sorties à jour lors d'un front montant (ou descendant) sur son entrée d'horloge. Entre deux fronts montants (ou descendants), le circuit ne réagit pas aux variations des entrées. Évidemment, l’horloge est envoyée au circuit via une entrée spéciale : l'entrée d'horloge.

Circuit séquentiel synchrone.

Dans le cas où notre circuit est composé de plusieurs sous-circuits devant être synchronisés via l’horloge, celle-ci est distribuée à tous les sous-circuits à travers un réseau de connexions électriques qu'on appelle l'arbre d'horloge.

Dans un ordinateur moderne, chaque composant d'un ordinateur a sa propre horloge, qui peut être plus ou moins rapide que les autres : par exemple, notre processeur fonctionne avec une horloge différente de l'horloge de la mémoire ! Ces signaux d'horloge dérivent d'une horloge de base qui est « transformée » en plusieurs horloges, grâce à des montages électroniques spécialisés (des PLL ou des montages à portes logiques un peu particuliers). La présence de plusieurs horloges vient du fait que certains composants informatiques sont plus lents que d'autres. Plutôt que de caler tous les composants d'un ordinateur sur le plus lent en utilisant une horloge, il vaut mieux utiliser des horloges différentes pour chaque composant : les mises à jour de registres sont synchronisées à l'intérieur d'un composant (dans un processeur, ou une mémoire), alors que les composants eux-mêmes synchronisent leurs communications avec d'autres mécanismes.

Les circuits asynchrones[modifier | modifier le wikicode]

Les circuits asynchrones n'utilisent pas d'horloge pour synchroniser leurs composants/sous-circuits. L’asynchrone permet à deux circuits/composants de se synchroniser, l'un des deux étant un émetteur, l'autre étant un récepteur. Quand le circuit émetteur a fait ses calculs, il peut envoyer ses données vers le second circuit. Celui-ci peut alors utiliser ces informations pour ses calculs, du moins quand il est prêt. Pour se synchroniser, le premier circuit va indiquer au second qu'il a fournit un résultat à destination du second circuit. Le second circuit va indiquer quand celui-ci a pris en copte les données envoyées. Cette synchronisation se fait grâce à des fils spécialisés du bus de commande, qui transmettent des bits particuliers.

Communication asynchrone

Codage simple-track des données[modifier | modifier le wikicode]

Généralement, cette synchronisation utilise deux fils : REQ et ACK. Le fil REQ indique au second composant que le premier lui a envoyé une donnée, tandis que le fil ACK indique que le second composant a finit son travail et accepte cette donnée indiquée par REQ. Lorsqu'un composant veut envoyer une information à un autre composant, celui-ci place le fil REQ à 1, afin de dire au récepteur : « attention, j'ai besoin que tu me fasses quelque chose ». Le composant à qui la donnée ou l'ordre est destiné va alors réagir et va faire ce qu'on lui a demandé. Une fois qu'il a terminé, celui-ci va alors positionner le fil ACK à 1 histoire de dire : j'ai terminé ! Plus rarement, un seul fil est utilisé à la fois pour la requête et l'acquittement : un 1 sur ce fil signifie qu'une requête est en attente (le second composant est occupé), tandis qu'un 0 indique que le second composant est libre. Ce fil est manipulé aussi bien par l'émetteur que par le récepteur. L'émetteur met ce fil à 1 pour envoyer une donnée, le récepteur le remet à 0 une fois qu'il est libre.

Signaux de commande d'un bus asynchrone

Codage dual-track des données[modifier | modifier le wikicode]

Habituellement, les circuits asynchrones utilisent un fil par bit de données, le signal REQ étant envoyé sur un seul fil. Mais cette manière de faire a quelques défauts, le principal étant la sensibilité aux délais. Pour faire simple, la conception du circuit doit prendre en compte le temps de propagation dans les fils : il faut garantir que le signal REQ arrive au second circuit après les données, ce qui est loin d'être trivial. Pour éviter cela, d'autres circuits ne fonctionnent pas sur ce principe. Ceux-ci utilisent plusieurs fils pour coder un seul bit, la majorité utilisant deux fils par bit.

Dual-rail protocol

Certains circuits asynchrones utilise un signal REQ par bit, d'où la présence de deux fils par bit : un pour le bit de données, et l'autre pour le signal REQ.

D'autres codent un bit de données sur deux bits, certaines valeurs indiquant un bit invalide.

Protocole 3 états

Les bascules synchrones[modifier | modifier le wikicode]

Utiliser une horloge demande cependant d'adapter les circuits vus précédemment, les bascules devant être modifiées. En effet, les bascules précédentes sont mises à jour quand un signal d'autorisation est mis à 1. Mais avec un signal d'horloge, les bascules doivent être mises à jour lors d'un front (montant ou descendant, peut importe) : seul un front peut ainsi commander la mise à jour de l'état du circuit, à savoir du contenu de ses bascules. L'horloge est reliée aux bascules du circuits, toutes les bascules ayant une entrée d'autorisation d'écriture modifiée.

Commençons par voir la bascule D, modifiée de manière à mettre à jour son contenu sur un front (montant). Celle-ci possède deux entrées : une entrée D sur laquelle on envoie la donnée à mémorisée (entrée d'écriture), et une autre sur laquelle on envoie l'horloge. Elle contient entre une et deux sorties : une pour la donnée mémorisée (sortie de lecture) et éventuellement une autre pour son opposé. Son fonctionnement est simple : son contenu est mis à jour avec ce qu'il y a sur l'entrée D, mais seulement lors d'un front montant (quelques bascules effectuent cependant la mise à jour non sur front montant, mais sur front descendant).

Entrée CLK Entrée D Sortie D
Front montant (ou descendant, suivant la bascule) 0 0
0 1 1
Pas de front montant 0 ou 1 Pas de changement
D Flip-flop.

Plus rares, certaines bascules D contiennent des entrées R et S pour les mettre à zéro ou à 1. La plupart des bascules D ont une entrée R pour les remettre à zéro, tandis que l'entrée S est absente, celle-ci étant peu utile.

D-Type Flip-flop

Bascule synchrone fabriquée avec des transistors[modifier | modifier le wikicode]

Il existe de nombreuses manières de créer une telle bascule, aussi allons-nous nous contenter des plus fréquentes et des plus simples. Le cas le plus complexe est celui où la bascule est intégralement réalisée avec des transistors. Nous n'étudierons pas ce cas, qui est franchement compliqué et relève plus de l'état de l'art que d’autre chose. Tout au plus, nous pouvons nous contenter de vous donner le circuit obtenu, pour le plaisir de vos yeux.

True single-phase edge-triggered flip-flop with reset

Bascule synchrone fabriquée avec des bascules RS[modifier | modifier le wikicode]

Il existe cependant des bascules D commandées sur front qui sont conçues intégralement avec des portes logiques. Plus précisément, ces bascules sont construites à partir d'un assemblage de portes logiques et de bascules plus élémentaires (des bascules RS ou D telles que vues plus haut). La première méthode pour concevoir de telles bascules est illustrée ci-dessous. Elle associe trois bascules RS normales, les deux premières formant une couche d'entrée qui commande la troisième bascule. Ces deux bascules d'entrée vont en quelque sorte traiter le signal à envoyer à la troisième bascule. Quand le signal d'horloge est à 0, les deux bascules d'entrée fournissent un 1 sur leur sortie : la troisième bascule reste donc dans son état précédent, sans aucune modification. Quand l'horloge passe à 1 (front montant), seule une des deux bascules va fournir un 1 en sortie, l'autre voyant sa sortie passer à 0. La bascule en question dépend de la valeur de D : un 0 sur l'entrée D force l'entrée R de la troisième bascule, un 1 forçant l'entrée S. Dit autrement, le contenu de la troisième bascule est mis à jour. Quand l'entrée d'horloge passe à 1, les bascules se figent toutes dans leur état précédent. Ainsi, la troisième bascule reste commandée par les deux bascules précédentes, qui maintiennent sont contenu (les entrées R et S restent à leur valeur obtenue lors du front montant).

Edge triggered D flip flop

Bascule synchrone fabriquée avec des bascules D[modifier | modifier le wikicode]

Une autre solution consiste à placer deux bascules D l'une à la suite de l'autre, en inversant leur signal d'autorisation d'écriture. Avec cette méthode, la première bascule est mise à jour quand l’horloge est 0, la seconde étant mise à jour avec le contenu de la première quand l'horloge est à 1. Dans ces conditions, la sortie final de la bascule est mise à jour après un front montant.

Negative-edge triggered master slave D flip-flop