La mémoire vive (RAM)#

Un registre retient un octet, mais un programme, lui, manipule des centaines ou des milliers de valeurs, et il faut aussi ranger quelque part la liste des instructions à exécuter. Aligner autant de registres nommés un par un serait ingérable. On regroupe donc un grand nombre de cases mémoire dans un seul composant, la mémoire vive, où l'on range et récupère les valeurs grâce à un numéro.

Qu'est-ce que la mémoire vive ?#

La mémoire vive, ou RAM (de l'anglais Random Access Memory), est une longue suite de cases, chacune capable de retenir une valeur, exactement comme un registre. Ce qui la rend utilisable, c'est que chaque case porte un numéro unique, son adresse : pour lire ou modifier une valeur, on ne fouille pas toute la mémoire, on donne simplement l'adresse de la case voulue.

Une colonne de huit cases numérotées de 0 à 7 ; la case d'adresse 2, mise en évidence, contient la valeur 1100

Une petite mémoire de 8 cases. Donner l'adresse 2 désigne directement la troisième case, sans toucher aux autres.#

C'est cet accès direct par le numéro qui donne son nom à la mémoire : "accès aléatoire" signifie ici qu'on atteint n'importe quelle case aussi vite, directement par son adresse, quel que soit l'endroit où elle se trouve.

Combien de cases peut-on adresser ? Une adresse est un nombre binaire : avec \(k\) bits d'adresse, on écrit les nombres de \(0\) à \(2^k - 1\), donc on peut désigner exactement \(2^k\) cases. On retrouve le lien vu avec le décodeur : 3 bits d'adresse donnent \(2^3 = 8\) cases, et pour adresser 256 cases il faut 8 bits.

Lire et écrire#

On ne fait que deux choses avec la mémoire : lire le contenu d'une case, ou y écrire une nouvelle valeur. Dans les deux cas, on commence par présenter l'adresse de la case concernée. La mémoire possède pour cela quelques entrées et une sortie :

  • une entrée adresse (notée A dans Logix) : le numéro de la case visée ;

  • une entrée donnée (notée D) : la valeur à écrire ;

  • une entrée écrire (souvent notée WE, pour write enable) : 1 pour écrire, 0 sinon ;

  • l'horloge clk (notée CLK) ;

  • une sortie lecture (notée Q) : le contenu de la case actuellement adressée.

Symbole de la mémoire RAM : entrées adresse (3 bits), donnée (4 bits), écrire, horloge, et sortie lecture (4 bits)

Le symbole d'une mémoire. Ici les adresses sont sur 3 bits (8 cases) et les valeurs sur 4 bits, pour rester lisible ; un vrai ordinateur en a bien davantage.#

Les deux opérations n'ont pas le même fonctionnement :

  • Lire ne modifie rien : la sortie lecture affiche en permanence le contenu de la case pointée par adresse. Il suffit de changer l'adresse pour voir aussitôt une autre case, sans front montant.

  • Écrire modifie la mémoire : quand écrire = 1, la valeur présente sur donnée est rangée dans la case adresse au prochain front montant, comme la charge d'un registre. Si écrire = 0, aucun front montant ne modifie la mémoire.

Essayez ci-dessous : écrivez une valeur à une adresse, puis relisez plusieurs cases en changeant seulement l'adresse. Vous pouvez également ouvrir cet exemple sur Logix, puis cliquer sur la RAM pour consulter son contenu en entier.

À l'intérieur : des registres et un décodeur#

Une mémoire n'a rien de magique : à l'intérieur, chaque case est un registre, comme ceux de la section précédente. Le seul ingrédient nouveau, c'est ce qui choisit quel registre lire ou écrire à partir de l'adresse. Et cet ingrédient, nous le connaissons déjà : c'est le décodeur.

Rappelons son rôle : un décodeur reçoit une adresse sur \(k\) bits et met à 1 une seule de ses \(2^k\) sorties, celle dont le numéro correspond à l'adresse. Il suffit alors de relier chaque sortie du décodeur à l'entrée LD d'un registre : la case dont l'adresse est présentée est la seule à recevoir l'ordre d'enregistrer, tandis que toutes les autres conservent leur contenu. Le décodeur transforme donc l'adresse en une sélection : "c'est cette case-là, et elle seule".

Dans Logix, le composant RAM contient déjà tout ce mécanisme : vous n'aurez pas à le reconstruire.

TP : la mémoire dans Logix#

Ce TP part du précédent : ouvrez dans Logix le fichier du TP registres (banc de registres + ALU). Vous allez y ajouter la mémoire qui contiendra le programme du processeur, puis la remplir avec des octets précis.

  1. La mémoire. Placez un composant RAM réglé sur des adresses de 4 bits et des données de 8 bits : Logix affiche alors RAM 16×8 sur le composant (16 cases d'un octet). Reliez son entrée CLK à la même horloge que les registres.

  2. Les commandes manuelles. Comme pour les registres, pilotez la mémoire à la main pour l'instant. Ajoutez :

    • une entrée adresse (4 bits), reliée à l'entrée A de la RAM ;

    • une entrée donnée mémoire (8 bits), reliée à l'entrée D ;

    • une entrée écrire (1 bit), reliée à l'entrée WE.

    Inutile d'ajouter un afficheur : la RAM montre elle-même, en binaire, le contenu de la case adressée (c'est aussi ce qui sort sur Q). Plus tard, c'est le compteur de programme qui fournira l'adresse.

  3. Rangez ces octets. Pour écrire une case : réglez adresse et donnée mémoire, mettez écrire = 1, faites un front montant, puis remettez écrire = 0. Rangez ainsi le contenu suivant :

    adresse

    contenu

    0000

    0001 0000

    0001

    0000 1101

    0010

    0001 0100

    0011

    0000 0010

    0100

    0100 0001

    0101

    0010 0000

    0110

    0000 0000

    La case 0110 doit contenir 0000 0000 : comme la mémoire part à zéro, il n'y a rien à y écrire.

  4. Vérifiez. Mettez écrire = 0, puis parcourez les adresses de 0000 à 0111 en changeant seulement adresse : la RAM doit afficher exactement le tableau ci-dessus, et 0000 0000 à l'adresse 0111. Vous pouvez aussi cliquer sur la RAM pour voir tout son contenu d'un coup. Si une case est fausse, réécrivez-la.

  5. Enregistrez votre circuit et gardez le fichier JSON. Ces octets ne sont pas choisis au hasard : au chapitre suivant, vous découvrirez qu'ils forment un petit programme, que votre processeur exécutera à la fin du cours.