L'unité de commande#
Aux TP précédents, vous avez construit l'ALU, le banc de registres et la mémoire,
qui contient déjà un petit programme. Mais c'est vous qui actionniez tout à la
main : vous choisissiez Rd et Rs, vous mettiez LD à 1, vous changiez
l'adresse de la mémoire... Pour que le processeur exécute son programme tout
seul, il faut remplacer ces interrupteurs par des circuits.
Nous allons y arriver pas à pas, en alternant théorie et pratique dans Logix :
Chercher les instructions : le compteur de programme
pc(en anglais program counter, TP 1), puis le registre d'instruction (TP 2).Exécuter les instructions : les deux étapes d'une instruction, le multiplexeur d'écriture et le registre de sortie. Vous ferez alors tourner le programme à la main, en jouant vous-même le rôle de l'unité de commande (TP 3).
Automatiser : l'unité de commande, qui remplacera vos interrupteurs (TP 4).
Le processeur complet#
Voici le processeur que vous aurez construit à la fin de cette page. Les composants des TP précédents sont reliés à quelques nouveaux composants.
Le processeur complet. Les flèches noires transportent des données ; les petits
signaux en bleu commandent les composants. La plupart viennent de l'unité de
commande, mais src est un simple fil issu de RI (vous verrez pourquoi).#
composant |
rôle |
dans Logix |
construit au |
|---|---|---|---|
banc de registres ( |
retient les valeurs de travail |
votre circuit |
TP registres |
ALU |
calcule (addition, soustraction, ...) |
votre composant |
TP ALU |
RAM |
contient le programme |
RAM |
TP mémoire |
compteur de programme |
contient l'adresse de la prochaine case à lire |
Compteur N-bit |
TP 1 |
registre d'instruction |
retient l'instruction lue : opcode, |
Registre N-bit et Tranches |
TP 2 |
multiplexeur d'écriture |
choisit ce qui entre dans le registre |
Multiplexeur |
TP 3 |
registre de sortie |
affiche la valeur d'un registre (instruction |
Registre N-bit |
TP 3 |
compteur d'étapes |
indique où en est l'instruction en cours |
Compteur N-bit et Décodeur |
TP 4 |
unité de commande |
produit les signaux de commande |
Décodeur et portes |
TP 4 |
Pas d'inquiétude si certains noms de la figure (T1, T2, src, lecture Rd...)
sont encore inconnus : chacun est expliqué plus bas, au moment où l'on en a besoin.
Partie 1 : chercher les instructions#
Le compteur de programme#
Pour exécuter le programme, le processeur doit lire les cases de la mémoire l'une
après l'autre. Jusqu'ici, c'est vous qui changiez l'adresse ; désormais, ce sera
le compteur de programme (pc, de l'anglais program counter).
C'est un compteur : un registre qui ajoute 1 à sa propre valeur à chaque
front montant. Il contient l'adresse de la prochaine case à lire.
Dans Logix, il s'appelle Compteur N-bit. Comme les autres composants, il a des entrées à gauche et une sortie à droite, chacune désignée par une abréviation anglaise :
connecteur |
de l'anglais |
rôle |
|---|---|---|
|
enable : activer |
quand |
|
load : charger |
quand |
|
data : donnée |
la valeur à charger ; non branchée, elle vaut |
|
clock : horloge |
l'horloge, dont les fronts montants font avancer le compteur |
|
(sortie) |
la valeur actuelle du compteur |
La sortie Q du pc est reliée à l'entrée A (address : adresse) de la RAM :
la RAM présente alors sur sa propre sortie Q le contenu de la case pointée.
Si l'on laisse D non branchée, l'entrée LD sert de remise à zéro.
Attention, ce LD ne fonctionne pas comme celui d'un registre : il agit tout de
suite, sans attendre de front montant, et tant qu'il vaut 1, le compteur reste
à 0 même si l'horloge avance. C'est pourquoi un reset se fait en deux temps :
1, puis 0.
Faites avancer l'horloge ci-dessous : le compteur ajoute 1 à chaque front
montant tant que l'interrupteur en vaut 1, et l'interrupteur reset, relié à
LD, le ramène à 0.
TP 1 : le compteur de programme#
Placez le compteur. Placez un Compteur N-bit, réglez-le sur 4 bits et nommez-le
pc. Reliez son entréeCLKà l'horloge, et sa sortieQà l'entréeA(l'adresse) de la RAM, à la place de l'entrée manuelleadresse: supprimez cette entrée.Faites le ménage. Supprimez aussi les entrées
écrireetdonnée mémoirede la RAM : le processeur ne fait que lire la mémoire, et une entrée non branchée vaut0.Pilotez-le à la main. Pour l'instant, c'est vous qui commandez le compteur. Ajoutez une entrée
incrémenter pc, reliée àEN(lepcavance quand elle vaut1), et une entréereset, reliée àLD(laissezDlibre : chargerD, c'est alors charger0).Vérifiez. Mettez
resetà1puis à0:pcvaut0000et la RAM affiche0001 0000. Mettezincrémenter pcà1et faites quelques fronts montants : la RAM affiche une à une les cases du programme (0000 1101,0001 0100,0000 0010...). Un nouveauresetvous ramène au début.
Solution
pc(Compteur N-bit, 4 bits) :Q→Ade la RAM,EN←incrémenter pc,LD←reset,CLK← horloge.Les entrées
adresse,écrireetdonnée mémoireont disparu. Les autres entrées manuelles (Rd,Rs,LD,donnée,op) sont encore là : elles seront remplacées dans les TP suivants.
Le registre d'instruction#
La RAM présente en permanence la case pointée par le pc. Mais dès que le pc
avance, cette case change ! Pour exécuter une instruction, le processeur doit donc
la garder quelque part : c'est le rôle du registre d'instruction (RI).
C'est un registre de 8 bits, un Registre N-bit, comme ceux du banc. Rappel de
ses connecteurs : D (data) reçoit la valeur à retenir, ici la sortie Q de la
RAM ; LD (load : charger) décide s'il capture : si LD vaut 1, le registre
copie D au prochain front montant, sinon il garde sa valeur ; CLK reçoit
l'horloge ; et la sortie Q donne la valeur retenue.
Une fois l'instruction dans RI, il reste à la découper en ses trois champs
(opcode, Rd et Rs, voir le chapitre précédent). C'est le rôle du composant
Tranche : il a une entrée (le mot complet) et une sortie (un champ de ce mot). Dans ses propriétés, Bit haut et
Bit bas donnent les numéros du premier et du dernier bit du champ, le bit 0
étant celui de droite. Trois Tranches extraient l'opcode (bits 7 à 4), Rd
(bits 3 et 2) et Rs (bits 1 et 0).
Les trois champs d'une instruction, rappel du chapitre précédent.#
Changez l'instruction ci-dessous et regardez les trois Tranches faire apparaître ses champs.
Rd et Rs vont directement au banc de registres : ce n'est plus vous qui
choisissez les registres, c'est l'instruction.
TP 2 : le registre d'instruction#
Placez RI. Placez un Registre N-bit de 8 bits nommé
RI. Reliez son entréeDà la sortieQde la RAM (la case lue), et sonCLKà l'horloge. Ajoutez une entréeLD RI, reliée à son entréeLD: quand elle vaut1,RIcapture la case lue au front montant.Découpez l'instruction. Ajoutez trois Tranches sur la sortie
QdeRI, et réglez leur Bit haut et leur Bit bas :7et4pour l'opcode,3et2pourRd,1et0pourRs.Branchez-les. La Tranche
Rdva partout où arrivait l'entrée manuelleRd: sur le décodeur du banc et sur l'entrée de sélectionseldu multiplexeurlecture Rd. La TrancheRsva sur l'entréeseldu multiplexeurlecture Rs. Supprimez ensuite les entrées manuellesRdetRs. L'opcodene servira qu'au TP 4.Vérifiez. Faites un
reset, puis mettezincrémenter pcetLD RIà1. Au premier front montant,RIcapture0001 0000(LOAD r0) et lepcpasse à0001. Faites un deuxième front montant :RIcapture0000 1101... qui n'est pas une instruction, mais la valeur13! Il faudra donc mettreLD RIà1au bon moment : c'est le sujet de la partie suivante.
Solution
RI(Registre N-bit, 8 bits) :D←Qde la RAM,LD←LD RI,CLK← horloge.Tranches sur la sortie de
RI: bits 7 à 4 (opcode, pas encore relié), 3 et 2 (Rd, vers le décodeur et le multiplexeur de lectureRd), 1 et 0 (Rs, vers le multiplexeur de lectureRs).
Partie 2 : exécuter les instructions#
Une instruction en deux étapes#
Un registre ne capture une valeur qu'au front montant. Or, pour savoir quoi
faire, le processeur doit d'abord avoir l'instruction dans RI. Une
instruction se déroule donc en deux étapes, une par front montant : pendant
T1, on va chercher l'instruction, que RI capture au front montant qui
termine T1 ; pendant T2, on l'exécute, et le front montant qui termine
T2 enregistre son résultat. Dans les tableaux, le front numéro k est toujours
celui qui termine l'étape de la ligne k.
Les signaux qui commandent les registres s'écrivent LD X ("charger X") : si
LD X vaut 1 pendant une étape, le registre X capture la valeur présente à
son entrée au front montant qui termine cette étape. LD Rd désigne le registre
dont le numéro est dans le champ Rd de l'instruction.
Une instruction occupe deux étapes, chercher (T1) puis exécuter (T2), entre
trois fronts montants : celui qui la commence, celui qui sépare T1 et T2, et
celui qui la termine (et commence l'instruction suivante). Le décodage n'est pas
une étape : il se fait en continu.#
Chercher (T1). La RAM présente en permanence la case dont l'adresse est dans
le pc. Au front montant qui termine T1, RI capture cette instruction et
le pc avance de 1 : pendant T1, LD RI et incrémenter pc valent 1. Il
n'y a pas de conflit : au front montant, tous les registres capturent en même
temps la valeur présente juste avant le front. RI reçoit donc bien la case
pointée par l'ancienne valeur du pc.
Exécuter (T2). La suite dépend de l'instruction : ranger une valeur dans un
registre, ou l'afficher. Il nous manque encore deux composants pour cela : le
multiplexeur d'écriture et le registre de sortie, juste après.
Le multiplexeur d'écriture#
Pendant T2, une instruction LOAD ou une instruction de calcul range une valeur
dans le registre Rd. Mais laquelle ?
Pour
LOAD Rd, valeur, c'est la valeur lue dans la mémoire (la case qui suit l'instruction : nous verrons plus bas comment la lire).Pour
ADD,SUB,ANDetOR, c'est le résultat de l'ALU.
Un multiplexeur d'écriture choisit donc ce qui entre dans le banc de registres.
Rappel : le Multiplexeur de Logix a des entrées de données numérotées 0, 1...
et une entrée de sélection sel (select) ; sa sortie recopie l'entrée dont le
numéro arrive sur sel. Ici, l'entrée 0 reçoit la sortie de la RAM, l'entrée
1 le résultat de l'ALU, et le signal branché sur sel s'appelle src (pour
source).
Comment régler src ? Grâce au choix des opcodes, c'est très simple. Les quatre
instructions de calcul (0100 à 0111) sont les seules dont l'opcode commence par
01, c'est-à-dire dont le bit 6 de RI vaut 1 (aucun de nos opcodes ne
commence par 1 : le bit 7 vaut toujours 0, il suffit donc de regarder le bit
6). On appelle ce bit calcul, et on le branche directement sur src :
src = calcul, sans aucune porte.
Et l'opération de l'ALU ? Inutile de la commander non plus : les deux bits de
droite de l'opcode sont le code op de l'ALU (SUB = 0101, donc
op = 01, la soustraction). On branche donc les bits 5 et 4 de RI
directement sur l'entrée op de l'ALU.
Le registre de sortie#
L'instruction OUT Rd montre le contenu du registre Rd. Le banc de registres le
lit déjà en permanence : c'est la lecture Rd, qui part vers l'entrée A de
l'ALU. Il suffit donc d'un registre de sortie de 8 bits dont l'entrée est la
lecture Rd : quand son signal LD sortie vaut 1, il capture cette valeur au
front montant. Un registre de Logix affiche toujours sa valeur : pas besoin
d'afficheur. C'est l'écran de notre processeur.
Les signaux de chaque étape#
Nous pouvons maintenant dire quels signaux valent 1 à chaque étape (src et
op, eux, se règlent tout seuls). Tous les autres valent 0.
étape |
instruction |
signaux à |
|---|---|---|
|
toutes |
|
|
|
|
|
|
|
|
|
|
|
|
aucun : il ne se passe rien |
LOAD demande un peu d'attention : sa valeur se trouve dans la case suivante
de la mémoire. Or, pendant T2, le pc pointe justement déjà sur cette case :
la RAM présente la valeur, le multiplexeur d'écriture la laisse passer
(src = 0) et Rd la capture. Au même front, le pc avance encore, pour passer
par-dessus la valeur.
TP 3 : jouez l'unité de commande#
Le multiplexeur d'écriture. Placez un Multiplexeur nommé
mux d'écriture, réglé sur Bits de sélection : 1 bit (2 voies) et Largeur des données : 8 bits. Entrée0: la sortieQde la RAM ; entrée1: le résultat de l'ALU. Reliez sa sortie à l'entréeDdes quatre registres, à la place de l'entrée manuelledonnée: supprimez-la.calcul et op. Ajoutez deux Tranches sur la sortie de
RI: le bit6seul (calcul: Bit haut et Bit bas à6), relié à l'entréeseldu multiplexeur d'écriture, et les bits5et4(op), reliés à l'entréeopde l'ALU à la place de l'entrée manuelleop: supprimez-la.Le registre de sortie. Placez un registre (Registre N-bit, et non le composant Sortie de la palette) de 8 bits nommé
sortie. Son entréeDest la lectureRddu banc (la sortie du multiplexeur qui alimente l'entréeAde l'ALU), sonCLKl'horloge. Ajoutez une entréeLD sortie, reliée à son entréeLD.Renommez l'entrée manuelle
LDdu banc (celle qui arrive sur les quatre portesET) enLD Rd.
Il vous reste quatre interrupteurs de commande : incrémenter pc, LD RI,
LD Rd et LD sortie. L'unité de commande, c'est vous ! Avant chaque front
montant, il faut les régler selon l'étape et l'instruction en cours. Le tableau
ci-dessous applique le tableau des signaux de chaque étape au programme de votre
RAM. Chaque ligne donne les réglages pendant l'étape : ils agissent au front
montant qui la termine. La colonne instruction indique l'instruction traitée ; pendant T1,
c'est celle qu'on va chercher (RI contient encore la précédente).
front |
étape |
instruction |
incrémenter |
|
|
|
|---|---|---|---|---|---|---|
1 |
|
|
|
|
|
|
2 |
|
|
|
|
|
|
3 |
|
|
|
|
|
|
4 |
|
|
|
|
|
|
5 |
|
|
|
|
|
|
6 |
|
|
|
|
|
|
7 |
|
|
|
|
|
|
8 |
|
|
|
|
|
|
Lancez le programme à la main. Faites un
reset. Puis, pour chaque ligne du tableau, réglez les quatre interrupteurs et faites un front montant. Vérifiez au passage : après le 2e front,r0vaut0000 1101; après le 4e,r1vaut0000 0010; après le 6e,r0vaut0000 1111; après le 8e, le registre de sortie affiche0000 1111, soit15.
Solution
mux d'écriture(Multiplexeur 8 bits, sélection 1 bit) :0←Qde la RAM,1← résultat de l'ALU,sel← Tranchecalcul(bit 6), sortie →Ddes quatre registres.Tranche
op(bits 5 et 4) →opde l'ALU.sortie(Registre N-bit, 8 bits) :D← lectureRd,LD←LD sortie.
Pendant T1, on cherche toujours l'instruction suivante : incrémenter pc et
LD RI valent 1, les autres 0. Pendant T2, on suit le tableau de l'étape
T2. Attention au 6e front : ADD n'occupe qu'une case, le pc ne doit
pas avancer.
Partie 3 : automatiser#
L'unité de commande#
Jouer l'unité de commande, c'est fastidieux : il est temps de la construire. Elle
fait exactement ce que vous faisiez à la main au TP 3 : à partir de l'étape en
cours et de l'opcode de l'instruction (dans RI), elle calcule chaque signal
avec quelques portes.
La logique de commande combine l'opcode et l'étape courante pour produire les signaux de commande.#
L'étape en cours. Un compteur de 1 bit (Compteur N-bit réglé sur 1 bit),
suivi d'un Décodeur 1 vers 2, suffit. Rappel : un Décodeur a une entrée et des
sorties numérotées 0, 1... ; seule la sortie dont le numéro est la valeur de
l'entrée vaut 1. Ici, la sortie 0 vaut 1 pendant T1, la sortie 1 pendant
T2, et chaque front montant fait passer à l'autre étape. Faites avancer
l'horloge ci-dessous pour le voir.
L'instruction. Un second Décodeur, 4 vers 16, transforme l'opcode en une
ligne par instruction ; pour les quatre instructions de calcul, le bit calcul
suffit :
opcode |
instruction |
ligne utilisée |
|---|---|---|
|
|
sortie |
|
|
sortie |
|
|
bit |
Les signaux. Il suffit de relire le tableau des signaux de chaque étape,
signal par signal. Par exemple, incrémenter pc vaut 1 à l'étape T1, et aussi
à l'étape T2 quand l'instruction est LOAD : T1 OU (LOAD ET T2). Un signal qui
dépend de l'instruction teste toujours aussi T2, car pendant T1, RI contient
encore l'instruction précédente.
signal |
relié à |
vaut |
|---|---|---|
|
|
|
incrémenter |
|
|
|
|
( |
|
|
|
|
sélection du multiplexeur d'écriture |
|
|
|
bits |
TP 4 : l'unité de commande#
Le compteur d'étapes. Placez un Compteur N-bit de 1 bit nommé
compteur d'étapes:CLK← horloge,LD←reset(unresetremet ainsi les deux compteurs à0),EN← une nouvelle entréeavancer, mise à1. Ajoutez un Décodeur de Largeur d'entrée 1 bit sur sa sortie : sortie0=T1, sortie1=T2. Deux lampes (Sortie)T1etT2permettent de voir l'étape.Le décodeur d'opcode. Placez un Décodeur de Largeur d'entrée 4 bits sur la Tranche
opcode: sa sortie1estLOAD, sa sortie2estOUT. Placez-le loin du décodeur d'étapes, pour ne pas confondre leurs sorties.Les signaux. Construisez chaque signal avec des portes (3 AND et 2 OR en tout), reliez-le là où arrivait son interrupteur, puis supprimez l'interrupteur :
LD RI=T1(un simple fil) ;incrémenter
pc=T1OU (LOADETT2) ;LD Rd= (calculOULOAD) ETT2(vers les quatre portesETdu banc) ;LD sortie=OUTETT2.
Lancez le programme. Faites un
reset, puis avancez l'horloge sans toucher à rien d'autre, et vérifiez :au 1er front montant,
T2s'allume,RIvaut0001 0000etpcvaut0001;au 2e,
r0vaut0000 1101;au 4e,
r1vaut0000 0010;au 6e,
r0vaut0000 1111;au 8e, le registre de sortie montre
0000 1111.
Si
r0reste à0au 2e front, vérifiezLD Rd; siRIne change jamais, vérifiez le filT1→LDdeRI; siT1etT2n'alternent pas, vérifiez queavancervaut1.Enregistrez votre processeur. Vous venez de construire un ordinateur.
Solution
Circuit corrigé : tp_processeur.json. Dans Logix, ouvrez-le avec le bouton Charger un JSON (flèche vers le haut).
Mettez reset à 1 puis à 0, puis cliquez sur l'horloge : le registre de
sortie montre 0000 1111 au 8e front montant.
L'unité de commande (3 portes ET, 2 portes OU) :
signal |
portes |
|---|---|
incrémenter |
|
|
( |
|
|
LD RI est relié directement à T1, op vient de la Tranche bits 5 et 4 de
RI, et calcul (la Tranche bit 6) commande directement le mux d'écriture.