Vers la pratique: un gros paquet de portes

Multiplexeur (MUX)

Premier élément d’électronique utile pour la suite, le multiplexeur : plusieurs entrées, un sélecteur et une sortie. En fonction de la valeur du sélecteur, c’est une des entrées qui apparaît en sortie. Ainsi, on numérote les entrées et on donne au sélecteur la valeur de l’entrée qu’on veut voir en sortie.

Par exemple, prenons un multiplexeur simple, dit 2 vers 1 : on a deux entrées, $e_0$ et $e_1$ (pouvant chacune valoir 0 ou 1), un sélecteur, $s_0$ (valant 0 pour la sélection de $e_0$, 1 pour $e_1$) et une sortie $q$ (dont la valeur dépend de l’entrée sélectionnée et de la valeur de cette entrée).

À quoi ressemble le circuit électrique correspondant à cet élément ? Pour le savoir, vous pouvez constater qu’on a ici 3 entrées et une sortie. Il s’agit donc d’une fonction booléenne de type $q(e_0,e_1,s_0)$. Le reste, c’est la création d’une table de vérité, puis la simplification par Karnaugh, comme on l’a vu ici. Vous essayez ?

Évidement, il existe des multiplexeurs 4 vers 1, 8 vers 1, 4 vers 2, etc. Néanmoins, le nombre de bits de sélection augmente avec le nombre d’entrée (4 entrées nécessitent 2 bits de sélections, 8 entrées nécessitent 3 bits de sélection, et ainsi de suite). Bien que ce soit ensuite un peu moins marrant à traiter avec Karnaugh, il est tout à fait possible d’arriver à des simplifications (en utilisant directement les règles de l’algèbre booléenne). Une autre manière de faire est de chaîner les multiplexeurs. Voici un exemple de multiplexeur 4 vers 1 réalisé à partir de multiplexeurs 2 vers 1.

Démultiplexeur (DEMUX)

À l’inverse, le démultiplexeur prend une entrée et la redirige vers la bonne sortie en fonction du sélecteur, ce qui donne l’équivalent électronique de l’aiguillage.

Cette fois, la fonction logique sera une série de « ET ». En effet, pour être active, une sortie donnée devra correspondre au sélecteur. Par exemple, dans le démultiplexeur donné plus haut, la fonction correspondante à la sortie « 0 » serait $q_0=\overline{s_0}\cdot e$ tandis que $q_1= s_0\cdot e$. Dès lors, à quoi ressemblera le circuit logique ?

Bien entendu, il existe des démultiplexeurs 1 vers 4, 8…

Bon, maintenant qu’on a vu les (dé)multiplexeur, on peut s’attaquer à un composant de base d’un processeur, c’est l’ALU, pour arithmetic logic unit (unité arithmétique et logique, en bon français). Dans un processeur, c’est ce type de circuit qui réalise toutes les opérations de base.

Une ALU prend un certain nombre de choses en entrée : deux mots, représentant des entiers et dont le nombre de bit dépend du processeur (32 ou 64 bits), $A$ et $B$, ainsi que l’opération à réaliser par l’ALU, l'opcode (pour operation code). On retrouve alors le résultat de l’opération en sortie, $Y$ (mot d’autant de bits que les entrées), ainsi qu’un certain nombre d’informations, regroupées sous le terme de statut (par exemple, pour citer quelque chose qu’on a déjà rencontré, l'overflow, mais aussi d’autres choses intéressantes).

En fonction de l’ALU, on peut réaliser un certain nombre d’opérations sur les entrées $A$ et $B$, telles que :

• Les mathématiques de base : addition, soustraction, complément à 2, éventuellement les multiplications et divisions, …
• Les opérations logiques: « ET », « OU », …
• Les comparaisons: $A \neq B$, $A < B$, …

D’autres opérations sont parfois disponibles dans des ALU spécialisées, telles que le calcul flottant (nombres à virgule), les décalages et rotations de bits, des opérations mathématiques plus complexes (racines carrées, exponentielle, logarithme et autres joyeusetés), mais le principe reste le même. Évidement, plus on rajoute d’opérations, plus les circuits associés sont complexes, le but ne va donc pas être ici de les passer en revue. Néanmoins, on va voir deux ou trois morceaux intéressants.

L’additionneur binaire

On avait fini le chapitre précédent en montrant qu’on pouvait implémenter les 5 opérations mathématiques de base à l’aide de l’addition et de quelques astuces. Il nous faut donc un circuit permettant de réaliser l’addition de 2 bits en position $i$ de $A$ et $B$, qu’on va noter $a_i$ et $b_i$, mais en gérant le report entrant, noté $c_{i}$, et pour stocker le tout dans le bit $i$ de $Y$, noté $y_i$, et en calculant s’il est nécessaire d’avoir un report sortant, $c_{i+1}$, pour la prochaine opération. Autrement dit, on est face à la table de vérité ci-dessous.

Il n’y a plus qu’à regarder quelles fonctions logiques on obtient alors.

• Pour ce qui est du résultat de l’addition, $y_i(a_i,b_i,c_i)=\overline{c_{i}}\cdot\overline{ a_i}\cdot b_i + \overline{c_{i}}\cdot a_i\cdot\overline{b_i}+c_{i}\cdot \overline{a_i}\cdot \overline{b_i} + c_{i}\cdot a_i \cdot b_i$, ce qui n’est pas simplifiable en utilisant Karnaugh (parce que ça donne un magnifique damier). Néanmoins, si on fait intervenir la porte XOR, $p\oplus q = \bar p\cdot q + p\cdot\bar q$, on peut obtenir une simplification en termes de nombre de portes logiques. Ainsi, cela revient à $y_i(a_i,b_i,c_{i})=c_{i}\oplus (a_i\oplus b_i)$. Vous pouvez même le vérifier par vous-mêmes¹.
• Pour le report sortant, on obtient cette fois quelque chose de simplifiable par Karnaugh. Une fois que c’est fait, on se rend compte que $c_{i+1}(a_i,b_i,c_i) = a_i\cdot b_i+c_i\,(a_i+b_i)$ (on gagne une porte en mettant $c_i$ en évidence).

Ne reste plus qu’à faire le circuit correspondant, ce que je vous laisse essayer :

Pour la suite, on va simplifier les choses en représentant l’additionneur binaire comme suit :

Une petite ALU 1 bit

Jusqu’ici, on peut juste réaliser l’addition. Qu’à cela ne tienne, on a vu que pour réaliser la soustraction, $A-B$, il suffisait de placer $c_0$ à 1, et d’additionner avec $\overline{b_i}$. On a donc besoin d’un signal, qu’on va appeller $inv_B$, qui donne $b_i$ si $inv_B={ 0}$ et $\overline{b_i}$ si $inv_B={ 1}$ autrement dit, $inv_B \oplus b_i$. Et le circuit permettant de réaliser la soustraction est donc simplement le suivant.

Bon, on aimerait aussi que notre ALU face un peu plus que l’addition et la soustraction, par exemple qu’elle face aussi le « ET » et le « OU ». Néanmoins, pour faire ça, on va avoir besoin d’un multiplexeur qui réalise le choix entre les différentes opérations à réaliser par l’ALU, qu’on va commander par le signal op. Tant qu’on est dedans, on va rajouter un signal $inv_A$ qui va permettre d’obtenir « NON ET » (comme $\overline{a_i}+\overline{b_i}$) et « NON OU » (comme $\overline{a_i}\cdot\overline{b_i}$). Et l’histoire de préparer la suite, on va également rajouter une entrée $p_i$, dont vous allez comprendre l’intérêt un peu plus bas.

Pour la suite, on va encore dézoomer d’un cran et représenter ce type d’ALU de la manière suivante.

Une « petite » ALU $n$ bits

Maitenant qu’on a une ALU 1 bit, on peut l’utiliser pour faire des calculs sur des nombres représentés sur plusieurs bits. Combien ? Comme ça a été dit dans le chapitre précédent, ça dépend du processeur, mais généralement 32 ou 64 bits, qui est la taille de la représentation des nombres entiers. De manière assez logique², une telle ALU sera alors formée de $n$ ALU 1 bit mises bout à bout pour traiter chacun des $n$ bits de $A$ et de $B$. Dès lors, on peut créer notre ALU comme suit.

Donc, qu’est-ce qu’on a là ? Vous devez reconnaître le centre : c’est là que se font les différentes opérations, bit par bit, comme promis. Pour que ça fonctionne, il faut évidement donner à chacune de ces ALUs les différents signaux op, $inv_A$ et $inv_B$.

Par contre, deux modifications ont été apportées afin que cette ALU soit capable de faire les comparaisons :

• La première, c’est pour réaliser la comparaison $A=B$. Pour ça, l’astuce est de calculer $A-B$, puisque si $A$ est égal à $B$, le résultat sera de… zéro. Ensuite, pour vérifier que c’est bien le cas, on fait passer le résultat de chaque soustraction bit à bit dans des portes « NON OU « (à droite dans le schéma). En effet, $x \downarrow y = 1 \Leftrightarrow a=b=0$ (voir le premier chapitre). Le résultat, c’est le signal zéro, qui vaut donc 1 si $A-B=0$, c’est-à-dire que $A=B$.
• La deuxième, basée sur la même astuce, c’est pour réaliser les comparaisons du type $A<B$. En effet, si $A<B$, $A-B$ est un nombre négatif. À l’inverse si $A>B$, $A-B$ est un nombre positif. Or on a vu que si un nombre était négatif, son bit en première position (le bit de poids fort) valait 1. C’est à ça que va servir la fameuse sortie $p$ qu’on a rajoutée plus haut. Si cette sortie est sélectionnée, tous les bits seront mis à zéro, sauf le premier, dont la valeur sera égale au bit de poids fort résultant de la soustraction de $A$ et $B$ ($set_p$ dans le schéma), ce qui explique en partie pourquoi l’ALU_n-1 est différente des autres (la partie « grise » contient quelques circuits supplémentaires pour gérer cela³). Autrement dit, si $A<B$, $Y=00\ldots001_2$, $00\ldots000_2$ sinon. Dans certains processeurs, c’est également un signal, comme zéro. À noter que le calcul dépend de si on compare des nombres signés ou pas (d’où le signal supplémentaire signe).

Et finalement, la dernière modification apportée est là pour permettre la détection de l'overflow, comme expliqué dans le chapitre précédent. Pour cela, il est nécessaire de connaître le report entrant et sortant ($c_{n-2}$ et $c_{n-1}$), ainsi que le fait qu’on travaille avec des nombres signés ou non. De même, c’est l’ALU_n-1 qui a été modifiée de manière à indiquer s’il y a dépassement ou non.

Et on a donc une ALU qui est capable de faire des opérations sur les nombres entiers signés ou pas, y compris des comparaisons. C’est rudimentaire, mais vous n’imaginez pas tout ce qu’on peut déjà faire avec ça.

Tout ça n’est toutefois pas très efficace. En effet, tout ça est très joli sur le papier, mais j’ai volontairement fait en sorte de ne pas complexifier la chose en omettant des aspects très importants qui reposent sur la petite note faite il y a deux chapitres : passer par une porte prend du temps ! Deux conséquences à cela :

• On a créé des scénarios de course (race condition, que les développeurs parmi vous connaissent peut-être déjà, parce que ce n’est pas limité à l’électronique). Par exemple :

  

  Imaginons qu’on change la valeur de $a$. Le passage par la porte « NON » implique un délai $\Delta{t_1}$ de temps, par rapport à la première entrée de la porte « ET », ce qui signifie que la valeur de sortie de cette porte « ET » n’est correcte qu’après un temps équivalent à $\Delta{t_1} + \Delta{t_2}$ (le passage par la porte « ET » impliquant un second délai $\Delta{t_2}$). Autrement dit, comme les changements ne sont pas instantanés, il faut attendre un certain temps pour que le système se « stabilise » avant de lire une valeur correcte. Pire, durant l’intervalle, la valeur en sortie de la porte « ET » est incorrecte. Il faut donc attendre un certain temps…

  Pour ceux que ça intéresse, ça se traite généralement en ajoutant de la redondance et/ou en simplifiant le circuit (comme c’est le cas ici).

• La création d’un circuit comme celui présenté plus haut où les unités sont mises à la chaîne induit un énorme problème généré par le calcul du report. En effet, le calcul du dernier reste ($c_n$) requiert de passer par rien de moins que $3n$ portes, sans compter le temps qu’il faut pour réaliser les opérations à la suite : le calcul de $y_i$ requiert le calcul de $c_i$, qui requiert le calcul de $c_{i-1}$, qui requiert celui de $c_{i-2}$, qui… rends le temps très long ! Ça impacte donc le nombre d’opération qu’on peut réaliser par seconde, et ce n’est pas quelque chose de souhaitable. Il existe cependant des solutions, par exemple le carry lookahead adder (« additionneur à retenue/report anticipée »), une alternative assez intelligente pour régler le problème du report et qui est une fois encore une application assez jolie de l’algèbre de Boole.

Bonus : et ainsi, on en arrive presque à l’assembleur

Si on résume, on a besoin de différents bits de contrôle nous permettant de réaliser tout un tas d’opérations. Et c’est là qu’intervient l’Assembleur. C’est quoi? C’est le langage de « programmation » le plus proche du pour communiquer avec le processeur. Ainsi, les instructions en Assembleur sont directement lues et interprétées par le CPU, qui va agir en fonction. Une instruction Assembleur contient un opcode (qui dit au CPU quoi faire) et des opérandes (qui dit au CPU quoi utiliser pour le faire). Évidement, cet opcode n’est pas un mot, mais un nombre en binaire, qui peut alors être passé à la moulinette de portes logiques pour déterminer de quelle opération il s’agit. Ainsi, dans un CPU, il ne serait pas illogique de retrouver sous une forme ou une autre dans cet opcode les différentes valeurs de $signe$, $inv_A$, $inv_B$ et $op$.

Le processeur trouve les données qu’il manipule dans des registres : il s’agit de zones mémoires très petites (typiquement, 1 mot) et à accès très rapide (à l’échelle du processeur). Quand on manipule une variable dans un langage de programmation, elle est en pratique copiée dans un registre avant d’être manipulée. Il existe, en fonction de l’architecture du processeur, un nombre de registre différent, mais ce nombre est en fait très faible comparé aux nombres de variables que peut manipuler un programme.

Le monde de l’Assembleur nécessiterait cependant un tutoriel à lui tout seul. En effet, les instructions sont spécifiques à un type de processeur (ARM ou intel, par exemple) et certaines subtilités existent (par exemple au niveau des registres). Néanmoins, le principe de base reste le même.

C’est quoi de la mémoire, en fait ? D’un point de vue tout à fait théorique, ce n’est jamais qu’une grosse fonction booléenne, pour laquelle la variable d’entrée est l’adresse, et la sortie est la valeur du bit situé à l’adresse demandée¹ (c’est le concept table de correspondance, look-up table (en), abrégé LUT).

Évidement, vous connaissez des éléments qui constituent « de la mémoire » pour un ordinateur. De tête, on pourrait probablement citer les CD/DVD/Blue Ray, les clés USB et autres cartes flash, les disques durs et SSD, ou encore la fameuse RAM (Random-Access Memory). Là-dedans, on peut quand même distinguer :

• La mémoire volatile et non-volatile. La mémoire volatile disparaît en l’absence d’alimentation électrique (c’est le cas de la RAM), la mémoire non-volatile existe indépendamment de l’alimentation (c’est le cas de tout les autres composants cités).
• La mémoire à accès séquentiels ou aléatoire (random). Une mémoire à accès aléatoire permet, en un temps rapide, d’accéder à un endroit précis, là ou une mémoire à accès séquentiels… Le permet, mais en un temps plus long. Un exemple typique du dernier cas sont les bandes magnétiques (oui, les cassettes audio, mais ça a longtemps servi comme support de sauvegarde pour les ordinateurs aussi, des programmes étaient même vendus comme ça). On se rend également compte que le terme « RAM » n’est absolument pas précis, puisqu’on pense aux barrettes mémoires de notre ordi, alors que le terme s’applique en fait très bien à un disque dur (qui permet aussi d’accéder à un endroit arbitraire en un temps court). Le terme exact pour les barrettes de RAM est en fait DRAM (dynamic random-access memory) (voir de la SDRAM si on veut pinailler sur les détails), comme on aura l’occasion de le voir plus loin.
• La manière de stocker les bits varie également d’un support à un autre. En ce qui concerne les disques optiques (45 tours, CD, DVD), il s’agit bien entendu de creux et de bosses. Le disque dur exploite lui les propriétés magnétiques de métaux (c’était également le cas des disquettes et de la bande magnétique, qui se base sur les propriétés magnétiques de l’oxyde de fer, plus communément appelé la rouille, d’où la couleur des bandes magnétiques d’ailleurs). Quant aux autres types de mémoire, on aura l’occasion d’en parler.

ROM ?

Avant de parler de mémoire volatile, passons un instant sur les ROM (read only memory). On leur donne aussi le petit nom de mémoire morte en français. Il s’agit simplement d’un circuit implémentant la fameuse fonction booléenne qui, pour une adresse entrée (dans les word lines), donne la valeur des bits en sortie (dans les bit lines), les unes et les autres étant reliés par ce qu’il faut de porte logique pour obtenir la fonction booléenne. Dans une version naïve, ces fonctions peuvent être implémentées simplement à l’aide de multiplexeurs, mais ça en ferait vite beaucoup. Une autre idée, c’est d’être plus systématique et en accord avec ce qu’on a vu dans le chapitre sur la logique booléenne : une fonction booléenne, c’est une disjonction de minterms (qui sont des conjonctions de littéraux, pour rappel). Du coup, on peut schématiser les choses comme suit.

Écrire une ROM demande donc de créer un circuit logique (c’est là que l’algorithme de Mc-Cluskey prend tout son sens, afin de demander à un ordinateur de faire le travail de simplification). Pour rendre ça un peu plus systématique, on a inventé des ROM « programmables » (les PROMS). L’idée de base, c’est un array de portes « ET », suivis d’un array de portes « OU », et par défaut, tout est interconnecté, mais la programmation de la ROM permet de changer ça. Voyons ça sur un exemple d’une ROM 4x2 bits:

Chaque petit rond bleu est une connexion qui peut être brisée (pour ça, on peut utiliser des fusibles que l’application d’une grande tension brise). C’est le processus de "programmation" d’une ROM : passer d’un circuit comme celui présenté plus haut à un circuit correspondant à la fonction logique qu’on souhaite implémenter. En l’occurrence, pour implémenter la fonction logique $f(a,b)=a\cdot b + \bar a \cdot b$ et $g(a,b)=\bar a \cdot \bar b + a\cdot \bar b$,

On trouve généralement un schéma simplifié pour exprimer la même chose.

Dans le cas d’une simple PROM (avec des fusibles), la programmation ne peut être effectuée qu’une fois (au moment de sa création). Mais on a par la suite inventé les EPROM et EEPROM, qui peuvent être reprogrammées après une exposition aux rayons UV pour la première et l’aide d’un courant électrique pour la seconde (ce qui est utile lorsqu’on fait du développement de circuit).

Les ROM étaient par exemple présentes dans les anciens BIOS ou était employée dans les cartouches de jeux vidéos auparavant² (en anglais, le mot pour les désigner est ROM cartridge, cartridge signifiant cartouche). On s’en sert toujours pour créer des tables de correspondances entre valeurs ou dans l’informatique embarquée.

Mais plus intéressant, les mémoires flashs et disque dur SSD sont en fait composés de ROM reprogrammables à l’aide de courant électriques.

Circuit avec rétroaction et logique combinatoire

Que vaut $r(a)$ dans le circuit suivant ?

Eh bien… Ça dépend. Ça dépend en fait de ce que vaut $a$ au temps $t$, bien entendu, ce qu’on va noter $a_t$, mais ça dépend également ce que valait $a$ avant, ce qu’on va noter $a_{t-1}$. En fait, on peut écrire le petit tableau suivant.

$a_{t-1}$	$a_t$	$r(a_t)$
0	0	0
1	0	1
0	1	1
1	1	1

En fait, le plus intéressant, c’est que si $a_t={0}$, alors le circuit ne change pas de résultat ($r({0})=a_{t-1}$). À l’inverse, si $a={1}$, alors le circuit change son état pour 1 ($r({1})={1}$), et rien ne pourra plus l’en faire sortir (sauf évidement de couper l’alimentation électrique). Le circuit est donc verrouillé (on parle d’un latch, en anglais).

Et ça, c’est très intéressant : d’une part parce qu’on vient de créer de la mémoire volatile (qui, ici, n’est pas réinscriptible, puisque si on inscrit 1, on ne peut plus en sortir), et d’autre par parce qu’on vient de mettre le doigt sur ce qu’on appelle de la logique séquentielle. En effet, jusqu’ici, on est resté dans le domaine de la logique combinatoire, ou la valeur d’une fonction booléenne dépend uniquement de ses entrées. Sauf que dans l’exemple ci-dessus, on a vu qu’il fallait également introduire la notion de temps, puisque la sortie de la fonction booléenne ne dépend plus seulement des valeurs d’entrée, mais également des valeurs précédentes (ou, comme on le verra plus loin, de l’instant où elles sont mesurées).

Bon, jusqu’ici, on a un circuit qui n’est pas très utile, mais on peut l’améliorer pour qu’il le soit en créant des « verroux ». L’un des exemples les plus utilisés, c’est celui qu’on peut créer avec deux portes NOR assemblées comme suit.

La table de vérité de ce circuit est la suivante.

$S$	$R$	$Q_t$	Note
0	0	$Q_{t-1}$	Lecture de la valeur de $Q$
0	1	0	Mise à 0 de $Q$
1	0	1	Mise à 1 de $Q$
1	1	X	Interdit

Là, on a un élément mémoire digne de ce nom. On voit que si on met $S$ à 1 (avec $R={0}$), on change la valeur de $Q$ telle qu’elle soit 1 (et ce quelle que soit sa valeur précédente): $\bar Q=S \downarrow Q_{t-1} = 0$ et ce quel que soit la valeur précédente de $Q_{t-1}$ (allez revoir la table de vérité de NOR si vous ne me croyez plus). Le reste suit logiquement : $R\downarrow \bar Q=1$, donc on arrive bien à la situation où $Q=1$.

À l’inverse, $R$ à 1 (avec $S={0}$) change la valeur de $Q$ pour 0. $S$ et $R$ sont simplement les premières lettres de set et reset. La valeur de $Q$ est lue en utilisant $R=S={0}$, c’est l’état verrouillé, comme dans le circuit précédent. À noter que $R=S={1}$ est interdit, parce que dans ce cas, on a droit à un magnifique scénario de course (enfin, grosso modo, $Q=\bar Q={0}$, ce qui n’a pas beaucoup de sens).

Ce verrou est dit transparent, dans le sens où un changement des entrées se répercute immédiatement sur la sortie. Et ça, ça peut être un problème à cause des scénarios de courses déjà mentionnés plus haut. Idéalement, on souhaiterait que le changement ne soit possible qu’à certains moments, on va donc ajouter une entrée qui permettra d’activer le changement, qu’on va noter $E$ (pour enable). Facile, il suffit d’ajouter des portes « ET » :

$E$	$S$	$R$	$Q_t$
0	X	X	$Q_{t-1}$
1	0	0	$Q_{t-1}$
1	0	1	0
1	1	0	1
1	1	1	X

Sauf qu’il y a une simplification possible ! En effet, lorsqu’on change l’état du verrou (avec $E={1}$), alors $S$ et $R$ sont opposés. Il suffit alors tout simplement de retirer l’une des deux entrées (on va renommer l’autre $D$ pour data), et d’utiliser une porte « NON » :

Ce qui simplifie la table de vérité :

$E$	$D$	$Q_t$	Note
0	X	$Q_{t-1}$	Pas de changements
1	0	0	Mise à 0 de $Q$
1	1	1	Mise à 1 de $Q$

L’horloge et les flip-flops

La gestion du temps

L’horloge, c’est tout d’abord un circuit capable de passer d’un état bas (0) à un état haut (1) et inversement $f$ fois par seconde, c’est ce qu’on appelle la fréquence. La période de l’horloge est donnée par $T=1/f$, c’est le temps qu’il faut au circuit pour partir de 0 et revenir à 0 (même chose avec 1). Avec un dessin,

Derrière tout ça se cache un matériau piézo-électrique, c’est-à-dire un matériau qui possède la capacité de changer de forme si on lui applique un potentiel électrique (c’est un cristal de quartz qui est employé ici, et si on connaît sa forme, on peut connaître assez précisément la fréquence).

On peut également introduire le rapport cyclique : c’est la fraction de la période durant laquelle le signal est haut. Ce rapport se calcule simplement comme $1\alpha = \tau /T$. Il est généralement de $^{1}/_{2}$. L’idée, c’est que c’est ce signal qui (en plus de donner l’heure) va synchroniser les circuits électriques. Autrement dit, on va s’arranger pour que les changements n’arrivent qu’à un instant précis (tout les $T$ intervalles de temps, évidement), puis on va laisser le temps au circuit pour se stabiliser, et on est assuré qu’après un certain temps (inférieur à $T$, ce qui fait que le choix de la période est crucial et dépend du plus lent des composants du circuit, rappelez-vous la remarque sur le calcul du report fait plus haut), la réponse qu’on mesurera(it) sera(it) la bonne.

Une fois qu’on possède un tel circuit d’horloge, on peut s’en servir pour synchroniser tous les circuits. Évidement, chacun de ceux-ci ne travaille pas à la même fréquence ($T$ plus ou moins long), mais on peut s’arranger (la mémoire vive fonctionne par exemple plus lentement que le processeur, et c’est sans parler des mémoires plus lentes telles que les disques [durs]). Notez que la modification de la fréquence d’horloge d’un processeur est tout à fait possible, on peut ainsi l’augmenter par overclocking (sur-cadençage pour les plus français d’entre nous), mais le processeur peut également faire le travail lui-même, souvent en réduisant la fréquence pour réduire la quantité de chaleur mais aussi en l’augmentant en cas de besoin (avec des technologies comme Intel Turbo Boost (en) et AMD PowerTune (en)).

Donc la première chose à tenter, c’est de brancher le signal $E$ de notre verrou D au signal d’horloge. Quand on fait ça, on a alors un système dont les valeurs ne peuvent être modifiées que quand le signal d’horloge est haut la valeur associée au signal est de 1). On passe alors d’un verrou à une bascule (flip-flop en anglais, rien à voir avec les « chaussures » du même nom), qui se distingue d’un verrou par le fait que le circuit correspondant est synchrone.

Edge-triggered flip-flops

C’est une bonne idée, mais… puisque durant tout cet intervalle de temps $\tau$, la valeur du verrou peut être modifiée, on est pas à l’abri d’un cas où la valeur de $D$ changerait plusieurs fois au cours de cet intervalle (à moins d’avoir un $\tau$ extrêmement faible). Du coup, on va ruser et permettre le changement uniquement quand le signal d’horloge change. Et pour ça, on peut imaginer plusieurs manières de faire. La première est de réaliser un circuit qui ne vaut 1 que quand le signal d’horloge change de valeur. Et pour ça, il suffit d’exploiter… Le scénario de course qu’on a vu plus haut, tout simplement. Imaginons que le temps pour passer au travers d’une porte « NON » soit de $\Delta{t}_1$ tandis que le passage dans une porte « ET » soit de $\Delta{t}_2$. On peut alors mesurer la réponse du circuit suivant au cours du temps :

On voit que le signal de sortie (en rouge) ne vaut 1 que durant un bref instant $\Delta{t}_1$ qui suis le front ascendant de $a$ (on voit qu’il n’y a pas de pic correspondant au front descendant de $a$). On a donc une espèce de détecteur de pulsation, donc il « suffit » de minimiser $\Delta{t}_2$ et de contrôler $\Delta{t}_1$ pour obtenir quelque chose d’utilisable pour contrôler précisément quand la valeur de la bascule peut être modifiée. Notez que si on veut réaliser un circuit qui détecte le front descendant, il suffit d’utiliser une porte « NOR » à la place du « ET ». On peut donc placer un tel circuit avant l’entrée $E$ d’un verrou D pour obtenir un système tout à fait décent.

Une autre manière de faire, c’est d’assembler en série deux verrous D, contrôlés par le même signal d’horloge, dans une configuration dite « maitre-esclave »:

Déjà, on peut noter que le second verrou (l’esclave) ne change de valeur que si le premier (le maître) change. On peut également noter que ce changement ne peut pas être simultané, puisque les entrées permettant la modification ($E$) sont inversée sur les deux verrous. Autrement dit, on ne peut éditer la valeur du maître que si le signal d’horloge vaut 1 (mais la lecture de $Q$ donnera toujours la valeur précédente), et une fois que le signal d’horloge passe à 0, l’esclave est mis à jour en conséquence (mais le maître ne peut plus être modifié). Autrement dit, ce système change de valeur sur le front descendant du signal d’horloge. Bien entendu, il y a moyen d’obtenir le même genre de circuit pour le front ascendant (en fait, il suffit de mettre une porte « NON » avant le signal d’entrée de l’horloge), mais l’idée reste la même.

Il existe bien entendu un symbole simplifié pour ces composants, que voici :

SRAM et DRAM

Registres et caches : SRAM

En fait, c’est comme pour l’ALU : le plus dur, c’est de faire le travail pour 1 bit, ensuite il suffit d’en mettre plusieurs d’affilée. Les registres n’y échappent pas :

On vient de créer ce qu’on appelle de la static random-access memory, ou SRAM (même si en pratique, ce n’est plus des bascules D qui sont utilisées). Celle-ci est plus rapide que la DRAM qu’on verra juste après, bien qu’elle prenne plus de place que cette dernière (et est plus coûteuse). C’est pour ça qu’on la retrouve principalement dans les registres (pour taper sur le clou : zones de mémoires directement manipulées par le processeur), ainsi que les mémoires caches (qui ne sont pas manipulées directement par le processeur, mais contiennent des données qui sont souvent manipulées par celui-ci, ce qui accélère le calcul parce que les données sont plus rapidement accessibles que s’il fallait aller les rechercher en mémoire vive, par exemple).

Bon, et la (S)DRAM, alors ?

Rien à voir. Une des causes du coût de la SRAM, c’est le nombre de portes logiques (et donc de transistors) qu’il est nécessaire pour les créer (entre 4 et 6). Eh bien la DRAM demande deux composant pour stocker un bit : un transistor (nMOS) et un condensateur.

Pour rappel, un transistor nMOS ne laisse passer le courant que si un potentiel est appliqué sur sa grille (c’est comme un interrupteur). Par ailleurs, on retrouve un condensateur, dont on avait déjà expliqué le fonctionnement il y a deux chapitres, mais disons simplement qu’il permet de stocker de l’électricité, comme une micro-batterie. Bref, le concept, c’est que le condensateur stocke la présence ou l’absence de bit par présence ou absence d’électricité. À partir de là, c’est facile : la charge du condensateur n’est modifiée que quand un potentiel haut (équivalent à 1) provient de la word line (ça signifie que la cellule a été choisie). Pour écrire dans la cellule DRAM, c’est le potentiel de la bit line qui va déterminer si le condensateur va être chargé (potentiel haut) ou déchargé (potentiel bas). Pour la lecture, c’est la décharge ou nom du condensateur qui va modifier le potentiel de la bit line (qui est préalablement placé à un potentiel intermédiaire entre haut et bas) et qui va permettre de savoir si le condensateur était chargé (1) ou déchargé (0).

Quelques petites choses à préciser, tout de même :

1. Ça signifie que quoiqu’il arrive, à la fin d’une opération de lecture, l’état du condensateur est inversé. Donc, il est nécessaire de faire suivre une opération de lecture par « une opération d’écriture » (recharger ou décharger le condensateur pour le replacer dans son état initial) !
2. Le problème des condensateurs, c’est qu’ils ne sont pas des batteries très efficaces et qu’ils laissent du coup « échapper » le courant très rapidement. Toutes les 64 ms (ou moins), une lecture est faite afin de réécrire les données à la suite et ainsi préserver l’état de la mémoire. C’est de ce besoin périodique de rafraîchissement que provient le « D » de DRAM (dynamic), là où la SRAM n’a pas besoin d’être rafraîchie.
3. On ne travaille pas par cellules individuelles, mais par « rangées » de cellules. Donc on lit par rangée, on rafraîchit l’état de toutes les cellules de la rangée en même temps et on profite d’une écriture pour également rafraîchir l’état de toute la rangée (pour être sûr). À cause de tout ça, la DRAM possède son propre circuit de gestion, indépendant du processeur et sa propre horloge (qui va normalement moins vite que celle du processeur). C’est la présence de cette horloge qui fait la SDRAM (pour synchroneous). On ne trouve aujourd’hui quasi plus que des SDRAM.
4. Le terme "DDR" signifie "double data rate" et s’applique uniquement à un certain type de SDRAM. Pour réaliser ce miracle, ces mémoires transfèrent des données non seulement sur le front montant, mais aussi sur le front descendant de l’horloge (évidement, l’électronique est adaptée en fonction). Les itérations suivantes (DDR2, DDR3 et DDR4) jouent sur le nombre de données qui peuvent être transférées simultanément, l’augmentation de la fréquence d’horloge et la réduction du voltage (qui entraîne sinon des surchauffes à cause de l’effet joule).

À noter que la gestion de la mémoire par un ordinateur est un sujet crucial pour les performances, d’une part au niveau du cache (pour que les données les plus utiles soient rapidement accessibles), d’autre par parce que la demande en mémoire d’un programme excède souvent la mémoire disponible (ce qui n’est pas un problème si on le gère convenablement, avec ce qu’on appelle la mémoire virtuelle, où on va mettre l’excédent moins utile sur le disque). Mais tout ça sort du cadre de ce tutoriel.