Registres et banc de registres

Contenu

Registres et banc de registres#

Nous savons maintenant retenir un bit avec une bascule. Pour construire un processeur, il faut retenir des octets entiers, et pouvoir choisir dans quel registre écrire et lequel lire. C'est le rôle des registres et du banc de registres.

Le registre#

Reprenons la bascule D du chapitre précédent : elle ne mémorise qu'un seul bit, capturé au moment précis d'un front montant de l'horloge clk. Pour retenir plusieurs bits à la fois, il suffit d'aligner plusieurs bascules D côte à côte et de les brancher sur la même horloge. On appelle cela un registre. Un registre construit avec 8 bascules D mémorise ainsi un octet entier d'un seul coup.

On ajoute presque toujours au registre une entrée de commande supplémentaire : la charge (load), notée LD dans Logix, comme sur les bascules D. Elle décide si le registre doit réellement enregistrer une nouvelle valeur au prochain front montant, ou s'il doit plutôt conserver ce qu'il contient déjà :

si LD = 1, la valeur présentée à l'entrée est capturée au prochain front montant ;
si LD = 0, le registre garde son contenu, même si l'horloge continue de battre.

Sans cette entrée, un registre recopierait sa donnée d'entrée à chaque front montant, qu'on le veuille ou non. Avec elle, on choisit précisément le moment où une nouvelle valeur doit être mémorisée, et celui où l'ancienne doit être préservée.

On représente un registre par un symbole unique, une simple boîte, plutôt que de dessiner toutes les bascules D séparées : une entrée de donnée (sur plusieurs bits), l'horloge clk, l'entrée LD, et une sortie qui présente en permanence la valeur mémorisée.

Symbole d'un registre 8 bits : une entrée de donnée sur 8 bits à gauche, une entrée LD, une horloge clk avec son triangle, et une sortie Q sur 8 bits à droite — Le symbole d'un registre 8 bits. Le trait barré d'un `8` rappelle qu'il s'agit d'un faisceau de 8 fils.#

Important

Un registre de n bits, c'est n bascules D partageant la même horloge clk: elles capturent toutes leur bit au même front montant.
L'entrée LD décide si le registre enregistre une nouvelle valeur (LD = 1) ou conserve la précédente (LD = 0).

Essayez ci-dessous. Réglez la donnée, mettez LD à 1 ou 0, puis faites un front montant d'horloge : la sortie ne change qu'au front montant, et seulement si LD = 1.

Le banc de registres#

Un processeur regroupe souvent quelques registres en un banc de registres : par exemple quatre registres r0, r1, r2, r3 qui servent de mémoire de travail. On a alors besoin de deux choses : choisir dans lequel écrire, et choisir lequel lire. Ce sont exactement les deux briques du chapitre sur le multiplexage :

pour écrire, un décodeur transforme le numéro du registre voulu en un signal LD dirigé vers ce seul registre (les autres conservent leur valeur) ;
pour lire, un multiplexeur choisit, selon un numéro, quel registre présente sa valeur en sortie.

Banc de registres : la donnée à écrire arrive sur les quatre registres r0 à r3 ; un décodeur commandé par Rd envoie LD à un seul registre ; deux multiplexeurs, dessinés l'un derrière l'autre et commandés par Rd et par Rs, choisissent les deux registres lus, qui partent vers les entrées A et B de l'ALU — Le banc de registres : le décodeur choisit où écrire ; deux multiplexeurs, dessinés l'un derrière l'autre, choisissent les deux registres lus (l'un selon `Rd`, l'autre selon `Rs`).#

La donnée à écrire arrive en même temps sur l'entrée des quatre registres. Seul celui qui reçoit LD = 1 (choisi par le décodeur) la capture au prochain front montant ; les trois autres l'ignorent et gardent leur valeur. Dans le processeur, un multiplexeur choisira quelle valeur présenter à cette entrée d'écriture : le résultat de l'ALU, une valeur lue en mémoire, ou le contenu d'un autre registre.

Un banc de registres n'est donc rien de plus que des registres, un décodeur et un multiplexeur assemblés. Nous nous en servirons pour construire le processeur.

Exercices#

Exercice 38#

Une fois câblé, changez les di et faites un front montant : les quatre bits sont bien enregistrés en même temps. C'est cette idée, n bascules D sous une même horloge, qui définit un registre.

Exercice 39#

À l'entrée du FriBowling, un afficheur montre le score de la partie en cours. Il est piloté par un registre R de 4 bits (valeurs de 0000 à 1111), muni d'une entrée LD : si LD = 1, R capture au prochain front montant la valeur présentée sur son entrée ; si LD = 0, R garde son contenu, quelle que soit la valeur présentée.

Voici, pour six fronts montants successifs, la valeur présentée à l'entrée et celle de LD. Au départ, avant le premier front montant, l'afficheur montre R = 0000. Complétez le contenu de R après chaque front montant (écrivez les 4 bits).

front montant	entrée	`LD`
1	`0111`	`1`
2	`1100`	`0`
3	`1100`	`1`
4	`1001`	`0`
5	`1111`	`1`
6	`0000`	`0`

Exercice 40#

Un processeur possède un banc de quatre registres r0, r1, r2 et r3. Avant le premier front montant, ils contiennent tous 0000 0000.

À chaque front montant, on présente une donnée (8 bits) à l'entrée d'écriture du banc, on choisit un registre avec Rd (2 bits : 00 = r0, 01 = r1, 10 = r2, 11 = r3) et on règle LD. Rappel : la donnée arrive sur l'entrée des quatre registres, mais seul le registre désigné par Rd la capture, et seulement si LD = 1.

front montant	donnée	`Rd`	`LD`
1	`0000 0111`	`10`	`1`
2	`0001 0100`	`00`	`1`
3	`0110 0011`	`01`	`0`
4	`0010 1010`	`10`	`1`
5	`1111 1111`	`11`	`1`

Complétez le contenu des quatre registres après chaque front montant.

front montant	`r0`	`r1`	`r2`	`r3`
avant	`0000 0000`	`0000 0000`	`0000 0000`	`0000 0000`
1
2
3
4
5

Solution

front montant	`r0`	`r1`	`r2`	`r3`
avant	`0000 0000`	`0000 0000`	`0000 0000`	`0000 0000`
1	`0000 0000`	`0000 0000`	`0000 0111`	`0000 0000`
2	`0001 0100`	`0000 0000`	`0000 0111`	`0000 0000`
3	`0001 0100`	`0000 0000`	`0000 0111`	`0000 0000`
4	`0001 0100`	`0000 0000`	`0010 1010`	`0000 0000`
5	`0001 0100`	`0000 0000`	`0010 1010`	`1111 1111`

Rd = 10 (r2) et LD = 1 : le décodeur envoie LD à r2 seulement. r2 capture 0000 0111, les autres restent à 0000 0000.
Rd = 00 (r0) et LD = 1 : r0 capture 0001 0100. r2 garde sa valeur.
LD = 0 : aucun registre ne reçoit la charge. Même si la donnée 0110 0011 arrive sur l'entrée des quatre registres et que Rd désigne r1, rien ne change.
Rd = 10 (r2) et LD = 1 : r2 capture 0010 1010. Son ancienne valeur est remplacée : un registre ne garde que la dernière valeur écrite.
Rd = 11 (r3) et LD = 1 : r3 capture 1111 1111, la plus grande valeur qu'un registre de 8 bits peut contenir.

TP : le banc de registres dans Logix#

Ce TP part du précédent : ouvrez dans Logix votre circuit ALU enregistré la dernière fois. Vous allez lui ajouter quatre registres pour en faire la mémoire de travail du processeur.

Quatre registres. Placez quatre registres (REG) r0 à r3 contenant des données de 8 bits, tous reliés à la même horloge clk.
Choisir où écrire. Ajoutez un décodeur : il reçoit un numéro Rd (2 bits) et envoie le signal LD vers un seul registre. Seul celui-là enregistrera au prochain front montant ; les autres gardent leur valeur.
Choisir quoi lire. Ajoutez deux multiplexeurs : l'un commandé par Rd, l'autre par Rs. Ils présentent en sortie le contenu de deux registres à la fois.
Brancher l'ALU. Reliez ces deux sorties aux entrées A et B de votre ALU, et reliez son entrée op à un interrupteur. Placez un afficheur sur la sortie de l'ALU.
La donnée à écrire. Ajoutez une entrée manuelle donnée (8 bits) et reliez-la directement à l'entrée de donnée des quatre registres. Seul le registre choisi par Rd et LD l'enregistre au front montant. (Plus tard, un multiplexeur choisira ce qui arrive sur ce fil.)
Testez à la main. Vous réglez tout avec des interrupteurs :
1. Écrire 0000 0101 dans r0 : donnée = 0000 0101, Rd = 00, LD = 1, faites un front montant.
2. Écrire 0000 0011 dans r1 : donnée = 0000 0011, Rd = 01, LD = 1, faites un front montant.
3. Lire et calculer : Rd = 00, Rs = 01, op = 00 (addition). L'afficheur de l'ALU indique 0000 1000.
Changez op pour voir les autres opérations sur ces deux mêmes registres.
Enregistrez votre circuit et gardez le fichier JSON : il servira à l'assemblage du processeur.