Fonctionnement d'un ordinateur/Les compteurs et timers

Les compteurs/décompteurs sont des circuits électroniques qui mémorisent un nombre et l'incrémentent à la demande. En clair, ce sont des registres améliorés afin de supporter l'incrémentation et la décrémentation. Pour donner un exemple d'utilisation, imaginez un circuit qui compte le nombre de voitures dans un parking dans la journée. Pour cela, vous allez prendre deux circuits qui détectent respectivement l'entrée ou la sortie d'une voiture, et un compteur. Le compteur est initialisé à 0 quand le parking est vide, puis est incrémenté à chaque entrée de voiture, décrémenté à chaque sortie. Les exemples de ce type sont suffisamment nombreux pour qu'on dédie un chapitre aux compteurs.

Un compteur mémorise un nombre qui est incrémenté ou décrémenté au besoin. Le nombre mémorisé sera appelé le décompte dans ce qui suit. Il est mémorisé dans un registre à l'intérieur du compteur. Au passage, le nombre de bits $n$ du compteur est appelé la taille du compteur, par analogie avec les registres. Il faut cependant faire la différence entre les compteurs d'un côté et les décompteurs de l'autre. Les compteurs incrémentent le décompte, les décompteurs le décrémentent, les compteurs-décompteurs peuvent faire les deux.

L'interface d'un compteur/décompteur

Les compteurs et décompteurs sont des circuits synchrones et ont donc une entrée d'horloge. Les compteurs les plus simples incrémentent leur contenu à chaque cycle d'horloge, mais les plus fréquents n'incrémentent le décompte que sur demande. Pour cela, ils disposent d'une entrée Count Enable, similaire à l'entrée Enable des registres, séparée de l'entrée d'horloge. Le décompte est incrémenté/décrémenté seulement si l'entrée Enable est à 1, lors d'un front adéquat sur le signal d'horloge.

Les compteurs ont aussi une entrée Reset qui permet de les remettre à zéro. Il y a parfois une entrée qui permet d'initialiser le compteur à une valeur par défaut, non-nulle. Par exemple, on peut initialiser le décompte à la valeur 5, ou une autre. Pour cela, le compteur dispose de deux entrées : une entrée sur laquelle envoyer le décompte initial, une entrée pour autoriser la réinitialisation. Les entrées en question sont appelées Preload Data et Preload Enable. La seconde entrée est parfois distincte de l'entrée de réinitialisation, pour permettre de réinitialiser le compteur soit à zéro, soit à la valeur voulue.

Il peut être utile de prévenir quand un débordement d'entier a lieu, à savoir quand le compteur n'a pas assez de bits pour encoder le décompte. Le compteur est alors remis à zéro, dans la plupart des cas. Mais il faut prévenir que le compteur a débordé, ce qui est utile pour fabriquer des circuits diviseurs de fréquence et des timers. Pour cela, on ajoute une sortie de débordement au compteur, qui est mise à 1 quand le compteur déborde.

Sur les compteurs/décompteurs, il y a une entrée Count Direction qui décide s'il faut compter ou décompter. Typiquement, elle est à 1 s'il faut compter et 0 s'il faut décompter.

Dans les schémas qui vont suivre, les entrées Enable ne sont pas représentées. Il est sous-entendu qu'il y a une entrée Enable pour tous les compteurs qui vont suivre. Il existe deux méthodes pour créer de tels compteurs : la première donne ce qu'on appelle des compteurs asynchrones, et l'autre des compteurs synchrones.

L'intérieur d'un compteur

A une exception bien précise qu'on abordera plus bas, les compteurs sont composés d'un registre, qui mémorise le décompte, couplé à un circuit incrémenteur. Nous avions déjà abordé l'incrémenteur dans un chapitre précédent, aussi je ne vais pas ré-expliquer comment il est conçu. Tout ce qu'il faut retenir est qu'il y en a plusieurs types, le plus simple étant celui à propagation de retenue.

Les compteurs synchrones basiques

L'incrémenteur le plus simple, à propagation de retenue, est fabriqué en enchainant des demi-additionneurs les uns à la suite des autres. Pour rappel, un demi-additionneur additionne deux bits. Ici, il additionne un bit de l'opérande, la retenue des colonnes précédentes. Pour le bit de poids faible, la retenue est forcé à 1. Si on combine un incrémenteur à propagation de retenue avec un registre, on obtient ce compteur :

Une simplification permet de faire disparaitre les portes XOR. Les portes XOR servent ici d'inverseur commandable, commandé par la retenue entrante. Elles inversent le contenu de la bascule quand la retenue entrante vaut 1, elles laissent la bascule inchangée si la retenue vaut 0. Or, nous avons déjà une bascule qui inverse son contenu sous certaines condition : la bascule T ! Il est donc possible de fusionner chaque bascule D avec la porte XOR associée, pour donner une bascule T. Le circuit final est celui-ci :

Il est possible d'optimiser le circuit avec les optimisations vues dans le chapitre sur les incrémenteurs. La première est le carry skip qui fait l'incrémentation non pas bit par bit, mais par paquets de deux bits. La seconde est l'anticipation de retenue. Et ces deux optimisations se marient bien avec ce qui va suivre.

Les compteurs en cascade

Il est possible de concevoir des compteurs à partir de compteurs plus petits, mis en cascade. Par exemple, en créant un compteur 8 bits à partir de deux compteurs 4 bits, enchainés l'un à la suite de l'autre. Idem avec 4 compteurs 4 bits, ce qui fait un compteur de 16 bits.

Les compteurs mis en cascade ont les mêmes entrées et sorties que les compteurs normaux, avec cependant un détail très important : ils ont une entrée pour la retenue entrante, et une sortie pour la retenue sortante. L'entrée pour la retenue entrante précise ce qui doit être additionné au bit de poids faible. Si elle vaut zéro, l'incrémenteur n'incrémente pas l'opérande. Si elle vaut 1, le compteur est incrémenté. L'entrée de retenue fait office d'entrée Count Enable, qui active ou désactive l'incrémentation.

Le compteur a aussi une sortie de débordement, qui indique que le compteur déborde. Il se trouve que cette sortie fournit la retenue pour le compteur suivant. La retenue peut être calculée en utilisant des optimisations comme l'anticipation de retenue, ce qui veut dire qu'elle est calculée sans propager les retenues, directement à partir des bits de l'opérande. Concrètement, la retenue est calculée en faisant un ET logique entre tous les bits du décompte.

Les compteurs sont mis en cascade de la manière suivante : leur sortie de débordement est connectée sur l'entrée Enable du compteur suivant, celle qui déclenche l'incrémentation du compteur. La sortie de débordement est notée RCO dans les schéma qui suivent, nous verrons pourquoi dans le prochaine paragraphe.

Les compteurs modulo

La plupart des compteurs comptent de 0 à $2^{n}-1$ , avec $n$ la taille du compteur. Mais d'autres compteurs ne comptent pas jusque-là. Par exemple, certains compteurs ne comptent que jusqu'à 10, 150, etc. Ils sont appelés des compteurs modulo. Prenons un compteur modulo 6, par exemple : il compte de 0 à 5, et est remis immédiatement à zéro quand il atteint 6. Il compte donc comme suit : 0, 1, 2, 3, 4, 5, 0, 1, 2, ...

Les compteurs modulo sont construits à partir d'un compteur normal, couplé à un circuit comparateur qui remet à zéro le registre quand il atteint la valeur maximale. Par exemple, on peut imaginer un compteur modulo 6 est construit à partir d'un compteur 4 bits qui compte de 0 à 15 (donc un compteur modulo 16), mais qui est remis à zéro quand il atteint 6. Le circuit comparateur vérifie si la valeur maximale 6 est atteinte et met à 1 l'entrée Reset si c'est le cas. Le comparateur est juste un comparateur avec une constante, que vous savez déjà fabriquer à cet endroit du cours.

Pour une minorité de compteurs, la valeur maximale est configurable. Le compteur est alors appelé un compteur programmable. Un compteur programmable contient un registre de configuration qui mémorise la valeur maximale souhaitée. A chaque cycle d'horloge, la valeur dans le compteur est comparée au registre de configuration. Si elles sont identiques, le compteur est remis à zéro. Le compteur est associé au registre de configuration et à un comparateur qui vérifie que les deux sont égaux. Pour le moment, nous ne savons pas faire de circuits comparateurs, ce qui fait qu'on ne peut pas expliquer ce circuit plus en détail.

Les compteurs ont tous une sortie de débordement, qui indique quand le compteur déborde. Pour les compteurs modulo, la sortie n'est autre que la sortie du comparateur. Pour les compteurs non-modulo, la sortie de débordement est une sortie du circuit combinatoire qui incrémente le compteur.

Les décompteurs et compteurs/décompteurs

Il est possible de créer un décompteur en couplant un registre avec un circuit décrémenteur. Cependant, il existe des alternatives assez intéressantes à étudier. L'une d'entre elle se base sur un principe mathématique assez simple, que je vais introduire par un exemple. Prenons un compteur 4 bits, qui compte de 0 à 15, et un décompteur 4 bits qui compte dans le sen inverse. Les deux parcourent les mêmes valeurs, mais dans le sens inverse. Regardons ce que cela donne en décimal :

Cycle 1	0000 (0)	1111 (15)
Cycle 2	0001 (1)	1110 (14)
Cycle 3	0010 (2)	1101 (13)
Cycle 4	0011 (3)	1100 (12)
Cycle 5	0100 (4)	1011 (11)
Cycle 6	0101 (5)	1010 (10)
Cycle 7	0110 (6)	1001 (9)
Cycle 8	0111 (7)	1000 (8)
Cycle 9	1000 (8)	0111 (7)
Cycle 10	1001(9)	0110 (6)
Cycle 11	1010 (10)	0101 (5)
Cycle 12	1011 (11)	0100 (4)
Cycle 13	1100 (12)	0011 (3)
Cycle 14	1101 (13)	0010 (2)
Cycle 15	1110(14)	0001 (1)
Cycle 16	1111 (15)	0000 (0)

La valeur d'un compteur et d'un compteur sont l'exact inverse l'un de l'autre ! Inverse dans le sens les bits sont inversés, les 0 devenant des 1 et réciproquement. Et cela ne marche pas que pour des compteurs ou décompteurs 4 bits, mais pour tous les compteurs et décompteurs.

Pour avoir un décompteur, il suffit donc de prendre un compteur et d'inverser sa sortie.

Les timers : compter des durées, compter des cycles d'horloge

Les timers, aussi appelés Programmable interval timer, sont des circuits capables de compter des durées, exprimées en cycles d'horloge. Leur fonctionnement est assez simple : ils émettent un signal quand un certain nombre de cycles est écoulé, ce nombre de cycles étant configurable. On peut ainsi générer un signal qui surviendra après 50 cycles d'horloge, ou après 100 cycles d'horloge, etc. Le signal en question est disponible sur une sortie de 1 bit, et correspond tout simplement au fait que cette sortie est mise à 1, pendant un cycle d'horloge.

Les timers peuvent compter de deux manières différentes, appelées mode une fois et mode périodique.

En mode une fois, le timer s'arrête une fois qu'il a atteint la limite configurée. On doit le réinitialiser manuellement, par l'intermédiaire du logiciel, pour l'utiliser une nouvelle fois. Cela permet de compter une certaine durée, exprimée en nombre de cycles d'horloge.
En mode périodique, le timer se réinitialise automatiquement avec la valeur de départ, ce qui fait qu'il reboucle à l'infini.

Les timers sont composés d'un compteur/décompteur cadencé par un signal d'horloge. Avec un compteur, le compteur est initialisé à 0, puis est incrémenté à chaque signal d'horloge, jusqu’à atteindre la valeur limite où il génère un signal. Pour un décompteur, c'est la même chose, sauf que le décompteur est initialisé à sa valeur limite, est décrémenté à chaque cycle, et envoie un signal quand il atteint 0. Les timers basés sur des décompteurs sont nettement plus simples que les autres, ce qui fait qu'ils sont plus utilisés.

Pour que les timers soient configurables, on doit pouvoir préciser combien de cycles il faut (dé-)compter avant d'émettre un signal. On peut ainsi préciser s'il faut émettre le signal après 32 cycles d'horloge, après les 50 cycles, tous les 129 cycles, etc. Le nombre de cycles en question est envoyé sur une entrée d’initialisation du compteur. Il peut être mémorisé dans un registre d’intervalle dédié.

Un ordinateur est rempli de timers divers. Dans ce qui va suivre, nous allons voir les principaux timers, qui sont actuellement intégrés dans les PC modernes. Ils se trouvent sur la carte mère ou dans le processeur, tout dépend du timer.

Le watchdog timer

Le watchdog timer est un timer spécifique dont le but est de redémarrer automatiquement l'ordinateur si jamais celui-ci ne répond plus ou plante. Beaucoup de PC s'en passent, mais ce timer est très fréquent dans les architectures embarquées. Le watchdog timer est un compteur/décompteur qui doit être réinitialisé régulièrement. S'il n'est pas réinitialisé, le watchdog timer déborde (revient à 0 ou atteint 0) et envoie un signal qui redémarre le système. Le système est conçu pour réinitialiser le watchdog timer régulièrement, ce qui signifie que le système n'est pas censé redémarrer. Si jamais le système dysfonctionne gravement, le système ne pourra pas réinitialiser le watchdog timer et le système est redémarré automatiquement ou mis en arrêt.

Le Time Stamp Counter des processeurs x86

Tous les processeurs des PC actuels sont des processeurs dits x86. Nous ne pouvons pas expliquer ce que cela signifie pour le moment, retenez juste ce terme. Sachez que tous les processeurs x86 contiennent un compteur de 64 bits, appelé le Time Stamp Counter, qui mémorise le nombre de cycles d'horloge qu'a effectué le processeur depuis son démarrage. Les programmes peuvent accéder à ce registre assez facilement, ce qui est utile pour faire des mesures ou comparer les performances de deux applications. Il permet de compter combien de cycles d'horloge met un morceau de code à s’exécuter, combien de cycles prend une instruction à s’exécuter, etc. Les processeurs non-x86 ont un registre équivalent, que ce soit les processeurs ARM ou d'autres.

Malheureusement, ce compteur est tombé en désuétude pour tout un tas de raisons. La principale est que les processeurs actuels font varier leur fréquence suivant les besoins. Ils augmentent leur fréquence quand on leur demande de faire beaucoup de calculs, et se mettent en mode basse(fréquence pour économiser de l'énergie si on ne leur demande pas grand chose. Avec une fréquence variable, le Time Stamp Counter perd complétement en fiabilité. Intel a tenté de corriger ce défaut en incrémentant ce registre à une fréquence constante, différente de celle du processeur, ce qui est encore le cas sur les processeurs Intel actuels. Le comportement est un peu différent sur les processeurs AMD, qui cadencent ce timer à la fréquence du processeur mais utilisent des mécanismes de synchronisation assez complexes pour corriger l'effet de la fréquence variable.

L'horloge temps réel

L'horloge temps réel est un timer qui génère une fréquence de 1024 Hz, soit près d'un Kilohertz. Dans ce qui suit, nous la noterons RTC, ce qui est l'acronyme du terme anglais Real Time Clock. La RTC prend en entrée un signal d'horloge de 32KHz, généré par un oscillateur à Quartz, et fournit en sortie un signal de fréquence 32 fois plus faible, c'est à dire de 1 KHz. Pour cela, elle est réglée en mode répétitif et son décompteur interne est initialisé à 32. La RTC génère donc un signal toutes les millisecondes, qui est envoyé au processeur. On peut, en théorie, changer la fréquence de la RTC, mais c'est rarement une bonne idée.

En théorie, la RTC permet de compter des durées assez courtes, comme le ping (le temps de latence d'un réseau, pour simplifier), le temps de rafraichissement de l'écran, ou bien d'autres choses. Mais dans les faits, l'horloge temps réel sa fréquence n'aide pas : 1024 Hz est proche de 1000, mais pas assez pour faire des mesures à la milliseconde près, chose qui est nécessaire pour mesurer le ping ou d'autres choses utiles. A la place, l'ordinateur l'utilise pour que l'ordinateur soit toujours à l'heure. L'ordinateur sait quelle heure il est avec une précision de l'ordre de la seconde (vous pouvez regarder le bureau de Windows dans le coin inférieur droite de votre écran pour vous en convaincre).

Le Programmable Interval Timer : l'Intel 8253

L'Intel 8253 était un timer programmable autrefois soudé sur les cartes mères des premiers PC. Il fût suivi par l'Intel 8254, qui en était une légère amélioration. Il était cadencé par une horloge maitre, générée par un oscillateur à Quartz, dont la fréquence est de 32 768 Hertz, soit 2^15 cycles d'horloge par seconde. S'il n'est plus présent dans un boitier sur la carte mère, on trouve toujours un circuit semblable au 8253 à l'intérieur du chipset de la carte mère, voire à l'intérieur du processeur, pour des raisons de compatibilité. L'intérieur de l'Intel 8253 est illustré ci-dessous. Nous allons expliquer l'ensemble de ce schéma, rassurez-vous, mais les explications seront plus simples à comprendre si vous survolez ce schéma en premier lieu.

L'Intel 8253 contient trois compteurs de 16 bits, numérotés 0, 1 et 2. Pour chaque compteur, l'entrée CLOCK est celle de l'horloge de 32 MHz, l'entrée GATE active ou désactive le compteur, la sortie fournit le signal voulu et/ou la fréquence de sortie. Les trois compteurs étaient utilisés pour dériver plusieurs fréquences allant de 18,2 Hz à environ 500 KHz. Par exemple, il était utilisé par défaut pour le rafraichissement de la mémoire (D)RAM, mais il était souvent reprogrammé pour servir à générer des fréquences spécifiques par le BIOS ou la carte graphique.

L'Intel 8253 lui-même possède plusieurs entrées et sorties. En premier lieu, on voit un port de 8 bits connecté aux trois compteurs, qui permet à l'Intel 8253 de communiquer avec le reste de l'ordinateur. La communication se fait dans les deux sens : soit de l'ordinateur vers les compteurs, soit des compteurs vers l'ordinateur. Dans le sens ordinateur -> compteurs, cela permet à l'ordinateur de programmer les compteurs, de les initialiser. Dans l'autre sens, cela permet de récupérer le contenu des compteurs, même si ce n'est pas très utilisé. Il y a aussi 5 entrées de configuration :

Deux bits A0 et A1 pour sélectionner le compteur voulu avec son numéro.
Un bit RD à mettre à 0 pour que l'ordinateur récupère le compteur sélectionné sur le port de 8 bits.
Un bit WR à mettre à 0 pour que l'ordinateur modifie le compteur sélectionné, en envoyant le nombre pour l'initialisation sur le port de 8 bits.
Un bit CS qui active ou désactive l'Intel 8253 et permet de l'allumer ou de l’éteindre.

L'Intel 8253 intégre un registre de 8 bits, le Control Word register qui mémorise la configuration de l'Intel 8253. Pour programmer les trois compteurs, il faut écrire un mot de 8 bits dans ce Control Word register. Pour écrire dans le Control Word register, il faut mettre le bit CS à 0 (on active l'Intel 8253), mettre le bit RDà 1 , le bit WR à 0 le bit WR (on indique qu'on fait une écriture), sélectionner le Control Word register en mettant les deux bits A0 et A1 à 1, puis envoyer la configuration du Control Word register sur le port de 8 bits.

Le High Precision Event Timer (HPET)

De nos jours, l'horloge temps réel et l'Intel 8253/8254 tendent à être remplacé par un autre timer, le High Precision Event Timer (HPET). Il s'agit d'un compteur de 64 bits, dont la fréquence est d'au moins 10 MHz. Il s'agit bien d'un compteur et non d'un décompteur. Il gère nativement plusieurs valeurs limites à laquelle générer un signal, qui sont configurables. Pour cela, il est couplé à plusieurs comparateurs, chacun associé à un registre pour mémoriser la valeur limite. Il doit y avoir au moins trois comparateurs/registres, mais le nombre peut monter jusqu’à 256.

Il faut noter que les systèmes d'exploitation conçus avant le HPET ne peuvent pas l'utiliser, pour des raisons de compatibilité matérielle. C'est le cas de Windows XP avant le Service Pack 3. C'est la raison pour laquelle les cartes mères émulent RTC et PIT dans leurs circuits. D'ailleurs, pour économiser des circuits, les cartes mères modernes émulent le PIT et la RTC avec le HPET : le premier comparateur fournisse la fréquence de 1024 Hz de la RTC, 3 autres comparateurs remplacent l'Intel 8253.

Le HPET gère de nombreux modes de fonctionnement : ses comparateurs peuvent être configuré en mode une fois ou périodique, on peut lui demander d'émuler la RTC et le PIT, etc. Chaque comparateur doit pouvoir fonctionner en mode une fois, et au moins un comparateur doit pouvoir fonctionner en mode périodique. Aussi, il contient aussi 3 registres de configuration. Notons qu'il est aussi possible de lire ou écrire dans le compteur de 64 bits, mais ce n'est pas recommandé.

Les compteurs en code Gray

Les compteurs classiques encodent leur décompte en binaire normal sur $n$ bits, mais il faut savoir que d'autres compteurs utilisent le BCD, d'autre le code Gray, etc. Nous allons voir dans ce qui suit ceux qui comptent en code Gray.

Pour rappel, le code Gray permet de coder des nombres d'une manière un peu différente du binaire normal. Son avantage principal est que lorsqu'on incrémente ou décrémente un nombre, seul un bit change ! Pour comparer, en binaire normal, lorsqu'on passe incrémente un nombre, il peut y avoir plusieurs bits qui changent. La moyenne est d'environ deux bits par incrémentation. Les compteurs en code Gray ont beaucoup d'avantages, qui sont tous liés à cette propriété.

Le premier l'absence d'état transitoires douteux. Le problème est que les bits modifiés par une incrémentation ne le sont pas en même temps. Les bits de poids faibles sont modifiés avant les autres. Évidemment, à la fin du calcul, on obtient le résultat final, correct. Mais pendant le temps de calcul, le compteur peut se retrouver dans un état transitoire, où seuls les bits de poids faibles ont été modifiés. C'est un problème si le contenu de ce compteur est relié à des circuits rapides, qui peuvent voir cet état transitoire, mais ne le doivent pas sous peine de dysfonctionner. L'usage de compteurs en code Gray permet d'éviter ce problème : vu que seul un bit est modifié lors d'une incrémentation/décrémentation, les états transitoires n'existent tout simplement pas.

Un exemple typique, évoqué dans les chapitres précédents, est l'échange d'informations entre deux domaines d'horloge. Pour rappel, il arrive que deux portions d'un circuit imprimé aillent à des fréquences différences : on dit que le circuit à plusieurs domaines d'horloge. S'il faut échanger des informations entre ces deux domaines d'horloge, divers problèmes surviennent. Un domaine d'horloge sera plus rapide que l'autre, et pourra voir les états transitoires invisible de l'autre circuit. Et par voir, on veut dire qu'il les prendra pour des états valides, ce qui fera dysfonctionner le circuit. Pour éviter cela, diverses techniques de croisement de domaines d'horloge existent. Et les compteurs Gray en font partie : si un domaine d'horloge utilise la valeur d'un compteur de l'autre, mieux vaut que ce compteur soit un compteur Gray. Et cette situation est assez fréquente !

Un autre avantage mineurs est que la consommation d'énergie de ces compteurs est bien plus réduite qu'avec un compteur normal. Rappelons que pour fonctionner, les circuits électroniques consomment un peu d'électricité. Et la majeure partie de cette consommation sert à faire passer un bit de 0 à 1 ou de 1 à 0. Ce qui fait que quand un compteur est incrémenté ou décrémenté, cela consomme un peu d'énergie électrique.

La moyenne pour un compteur binaire normal est de 2 bits changés par incrémentation/décrémentation, contre un seul pour un compteur Gray, on devine que ces derniers consomment deux fois moins d'énergie par incrémentation. Et cet avantage a des effets en cascade sur les circuits qui suivent ce compteur. Si l'entrée de ces circuits ne change que d'un seul bit, alors leur état changera moins que si c'était deux bits. Les circuits qui suivent vont donc moins consommer.

Un autre avantage en matière de consommation énergétique est lié auxs transitions d'état douteuses. Les circuits connectés au compteur vont voir ces transitions d'état douteuses et modifier leur état interne en réaction. Bien sur, l'état final correct sera atteint une fois que le compteur sera stabilisé, ce qui effacera ces états transitoires intermédiaires. Mais chaque état intermédiaire transitoire correspond à un changement d'état, donc à une consommation d'énergie. En supprimant ces états transitoires, on réduit fortement la consommation d'énergie du circuit. Cela vaut pour le compteur Gray lui-même, mais aussi sur tous les circuits qui ont ce compteur comme entrée !

◄ Retour vers « Les registres et mémoires adressables »

Sommaire du livre

Continuer vers « Les registres à décalage et les LSFR » ►