0.1 La machine à calculer

Les processeurs ne sont rien d’autres que des machines à calculer (un peu évoluées) programmables. Imaginez que vous êtes comptable, et que vous ayez à effectuer une série d’opérations qu’on vous a gentiment inscrites sur une feuille de papier. Voici un exemple d’instructions qu’on peut vous avoir donné :

1. faire 112 + 3
2. faire 4 + 5
3. faire 2 + 16
4. …

Un exemple un peu plus compliqué serait :

1. faire 112 + 2
2. faire “résultat précédent” * 5
3. …

ou bien

1. 112 + 3
2. résultat précédent - 4
3. si le résultat est nul, passer à l’étape 6, sinon continuer
4. 3 * 4
5. résultat précédent + 9
6. ouvrir la fenêtre
7. résultat de l’étape 2 - 15
8. passer à l’étape 12
9. …

Un microprocesseur est un dispositif électronique qui pourrait faire ce travail à votre place, pourvu qu’on lui donne la feuille de papier (et de l’énergie).

0.2 Instructions et données

Les séries d’opérations ci-dessus sont appelées programmes. En d’autres termes, un programme de microprocesseur est juste une liste d’opérations à effectuer. Dans notre cas, où le microprocesseur est simple, les instructions resteront simples et en petit nombre.

Dans la littérature, on nomme ce genre de processeur "processeur RISC" (pour Reduced Instruction Set  Computer).

Si le processeur est plus complexe, incluant des périphériques multiples (gestionnaire de mémoire, entrées-sorties, …), les instructions peuvent devenir très complexes et très nombreuses. La dénomination consacrée à ce genre de processeur est CISC (pour Complex Instruction Set Processor).

Dans les suites d’opérations ci-dessus, on distingue deux types d’objets :

• les données :
  • d’abord les opérandes proprement dits (“3”, “4”, “112”, …),
  • et les opérandes implicites (“résultat précédent”, “résultat de l’étape 2”, …);
• les instructions :
  • pour nous ce sont principalement les opérations (au sens arithmétique du terme) à effectuer (“+”, “−”, “*”, “/”...),
  • il y a aussi des tests (“si le résultat précédent est nul...”),
  • et des sauts, conditionnés par un test (“alors passer à l’étape 6”) ou non (“passer à l’étape 12”)
  • ainsi que des instructions spéciales (“ouvrir la fenêtre”). Dans notre cas, une instruction de ce genre pourrait être “mettre en marche le buzzer”, ou “allumer la LED numéro 10”...

Notez que ces suites d’opérations sont numérotées : elles ont un ordre. Dans le premier exemple, l’ordre n’a pas tellement d’importance, mais il en a une dans le deuxième et le troisième quand on parle de “résultat précédent”, d’“étape 6”, …

0.3 De la feuille à l’électronique

Passons du comptable et de la feuille de papier aux composants électronique.

La feuille de papier a un rôle de mémorisation :

• c’est sur elle qu’est écrite la suite d’opérations à effectuer,
• c’est probablement aussi sur elle que seront écrit les résultats.

Nous la modéliserons par une mémoire vive, une RAM (pour Random Access Memory). C’est cette RAM qui stockera les instructions à effectuer, les données, ainsi que les résultats que le microprocesseur va calculer. Le microprocesseur sera donc relié à cette RAM, et ira lire les instructions à effectuer, selon le principe suivant :

• aller lire la première ligne (instructions et données associées)
• faire ce qui est indiqué
• aller lire la ligne suivante (instructions et données associées)
• faire ce qui est indiqué
• revenir à l’étape 3 (etc. jusqu’à ce que mort s’ensuive...)

Première remarque

: le microprocesseur doit lire les lignes une par une. Il doit donc maintenir un compteur de ligne interne qui indique la ligne courante (ou la prochaine ligne à lire, comme cela nous arrangera).

Deuxième remarque

: le processeur est un dispositif électronique qui ne comprend que des suites de bits. Il faudra donc coder les instructions sur un nombre de bit suffisant pour coder toutes les instructions dont nous aurons besoin. Les données seront limitées à des entiers naturels (positifs) et il faudra trouver un moyen de coder les données implicites.

Troisième remarque

: dans notre architecture, la RAM stockera les données et les instructions de façon imbriquée. Il est possible d’utiliser deux RAM différentes, ou des zones distinctes, mais ce n’est pas l’objet de ce cours.

0.4 Interlude rappel : fonctionnement de la RAM

Le schéma de la RAM est donné en figure 1.1.

La RAM possède trois bus :

• un bus d’adresses, ADDRESS[7:0] indiquant l’emplacement en mémoire de la donnée à laquelle on accède,
• un bus de donnée, D[7:0], pour les données qu’on écrit en RAM,
• un bus de donnée, Q[7:0], pour les données qu’on va lire en RAM,

ainsi que

• un signal de contrôle sur 1 bit, WRITE, indiquant si on est entrain de faire une lecturedans la RAM (WRITE=0), ou une écriture (WRITE=1).

Le fonctionnement de la RAM est le suivant :

• la RAM sort en permanence sur Q[ ] la donnée stockée à l’adresse présente sur ADRESSE[ ]
• (après, Q[ ], on en fait ce qu’on veut... Si on n’a pas envie de l’utiliser, on l’ignore),
• si WRITE est actif (1), la valeur présente sur D[ ] est stockée à l’adresse présente sur ADRESSE[ ],
• si WRITE est inactif (0), D[ ] est ignoré.
• De plus, pendant que WRITE est actif, le bus Q[ ] prend la même valeur de D[ ].

Pour les chronogrammes, on se reportera à la figure 1.2

Nous relierons notre microprocesseur (automate) à une RAM pouvant stocker 256 mots de 8 bits chacun :

• 8 bits : les lignes de données D[ ] seront un bus 8 bits
• 256 mots : il nous faudra donc 8 bits d’adresse (pour coder une adresse allant de 0 à 255)

L’architecture globale, qui nous re-servira en TP est donc la suivante (voir figure 1.3)

• notre microprocesseur
• la RAM, reliée au processeur par ses bus de données, adresses et la ligne de WRITE
• un buzzer qui servira à jouer de la musique

Dans cette première étape, nous n’implémenterons que les instructions et données du premier exemple. Le processeur est donc relié à une mémoire vive (RAM) stockant 256 mots de 8 bits.

1.1 Organisation de la mémoire

On suppose que le programme (opérations à effectuer) ainsi que les données sont déjà chargées dans la mémoire, et qu’ils respectent le format suivant :

Le “X” indique que la RAM ne contient rien de valide à cet endroit là. C’est au microprocesseur d’aller y écrire le résultat correct. Après avoir lancé le microprocesseur, le contenu de la RAM sera donc le suivant (on indique en gras les endroits de la RAM qui ont changé) :

Remarques :

• le microprocesseur doit commencer son exécution à l’adresse 0 de la mémoire,
• on part donc du principe qu’on aura donc toujours une instruction à l’adresse 0 de la mémoire,
• et qu’on aura toujours en mémoire une instruction, puis l’opérande 1, puis l’opérande 2, puis un octet pour stocker le résultat

1.2 Les instructions

Elles seront (pour l’instant) au nombre de deux :

Ces opérations arithmétiques opèrent sur des nombres de 8 bits, représentant des entiers non signés. Les instructions étant stockées en RAM, il est nécessaire de les coder. Comme la RAM stocke des mots de 8 bits, ça nous donne 256 instructions possibles, ce qui est largement suffisant pour un processeur basique... Le code choisi ci-dessus pour l’addition et la soustraction est parfaitement arbitraire : il correspond à celui qui sera implémenté en TP.

1.3 Fonctionnement de l’automate

Vue l’organisation de la RAM qui a été choisie, le fonctionnement de l’automate est simple : à chaque coup d’horloge, il va chercher successivement une instruction, puis le premier opérande, puis le deuxième opérande, calcule le résultat et le stocke. Puis il recommence à l’adresse suivante.

En détail :

1. Premier coup d’horloge : le microprocesseur présente l’adresse “0” à la RAM.
   La RAM lui présente donc sur son bus de sortie le contenu de l’adresse 0, qui est la première instruction.
2. Deuxième coup d’horloge : le microprocesseur incrémente l’adresse qu’il présente à la RAM (“1”).
   La RAM lui présente donc sur son bus de sortie le contenu de l’adresse 1, qui est le premier opérande.
3. Troisième coup d’horloge : le microprocesseur incrémente l’adresse qu’il présente à la RAM (“2”).
   La RAM lui présente donc sur son bus de sortie le contenu de l’adresse 2, qui est la deuxième opérande.
   A ce moment là, le microprocesseur dispose de toutes données nécessaire au calcul : l’instruction, et les deux opérandes. Il peut donc calculer le résultat.
4. Quatrième coup d’horloge : le microprocesseur incrémente l’adresse qu’il présente à la RAM (“3”).
   Parallèlement, il présente sur le bus de donnée en entrée de la RAM le résultat qu’il vient de calculer.
   Parallèlement, il passe la ligne WRITE de la RAM à l’état haut, pour dire à la mémoire qu’il désire effectuer une écriture.
   Le résultat du calcul est donc à ce moment là écrit à l’adresse “3” de la mémoire.
5. Cinquième coup d’horloge : le microprocesseur incrémente l’adresse qu’il présente à la RAM (“4”).
   La RAM lui présente donc sur son bus de sortie le contenu de l’adresse 4, qui est la deuxième instruction.
6. etc...

Question 1:

Concevoir l’architecture de cet automate.

On ne demande pas une représentation de toutes les portes logique de l’automate, mais juste une représentation de haut niveau : vous disposez de registres, de boites combinatoires dont vous ne donnerez que les équations, de multiplexeurs, de compteurs, etc.

2.1 Chaînage des opérations

L’architecture actuelle ne permet pas de chaîner les calculs (exemple : 3 + 4 + 5). Pour pouvoir le faire, il y a plusieurs possibilités…

Question 2: Lesquelles ?

2.2 L’accumulateur

Nous allons doter notre processeur d’un registre interne sur 8 bits, que nous appellerons accumulateur. Toutes les opérations arithmétiques à deux opérandes s’effectueront entre l’accumulateur et une donnée en RAM. Plus précisément : pour effectuer “3 + 4” et stocker le résultat en RAM, le processeur effectuera les instructions suivantes :

1. chargement de 3 dans l’accumulateur
2. addition de l’accumulateur avec un opérande en RAM (“4”)
3. stockage du contenu de l’accumulateur en RAM

Pour effectuer “3 + 4 + 5” :

1. chargement de 3 dans l’accumulateur
2. addition de l’accumulateur avec un opérande en RAM (“4”)
3. addition de l’accumulateur avec un opérande en RAM (“5”)
4. stockage du contenu de l’accumulateur en RAM

On ajoute donc deux instructions à notre processeur :

• load : chargement de l’accumulateur à partir de la RAM
• store : stockage du contenu de l’accumulateur dans la RAM

Parallèlement, les instructions d’addition et de soustraction n’ont plus besoin que d’un seul opérande - le deuxième opérande est dans l’accumulateur.

De plus, tant qu’on y est, nous allons ajouter trois instructions de manipulation de bits : AND, OR et XOR (cf. le tableau 1.1), qui comme l’addition, opèrent sur le contenu de l’accumulateur et un opérande en RAM.

Le nouveau jeu d’instruction devient donc :

Question 3: Quel est l’impact de ces spécifications sur la façon de stocker le programme en RAM ?

Question 4: Concevoir la nouvelle architecture du processeur. Quels sont les avantages en terme de vitesse par rapport à l’architecture précédente ?

3.1 Indirection

Imaginez qu’on souhaite séparer le code des données, pour :

• faire tourner un même code sur des données différentes (sans le dupliquer pour chaque set de donnée...)
• faire tourner différents codes sur des mêmes données (sans dupliquer les sets de données...)
• faire tourner un code sur des données qui ne sont pas connues avant l’exécution du programme (du genre, le début du programme demande à l’utilisateur d’entrer des valeurs...)

Pour le moment, notre processeur ne sait pas faire : on doit connaître les données au moment du pré-chargement de la RAM avec le code...

Il faudrait disposer d’instructions de manipulation du contenu de la RAM à des endroits arbitraires (on ne modifierait que des données, hein, pas le code...) Cela permettrait d’aller modifier les zones où se trouvent les opérandes. Mais c’est peut-être un peu compliqué d’avoir à modifier plein de zones éparses.

Pour être plus propre, on pourrait séparer le code des données. On aurait, en RAM, une zone avec les instructions et une zone avec les données. Il suffirait juste d’aller modifier la zone des données, et d’exécuter le code générique qui saurait, pour chaque instruction, où trouver les bons opérandes.

Pour cela, on modifie (toutes) les instructions de la façon suivante : au lieu d’avoir en RAM deux octets instruction - opérande, on aura plutôt instruction - adresse de l’opérande.

Par exemple, pour effectuer “3 + 4, 3 − 1” on pourra voir une organisation du genre (voir tableau 1.2):

Après l’exécution du code, on aura ceci en RAM (voir tableau 1.3)

Remarque : d’habitude on sépare même la zone de données en deux, celles qui sont connues à l’écriture du programme, et les autres (celles qui sont modifiées par le programme)...

Question 5: Proposer une modification de l’automate pour que les instructions travaillent avec des adresses d’opérandes...

L’architecture actuelle ne sait effectuer que des calculs linéaires (suite fixe d’instructions), sur des données potentiellement inconnues (mais dont les adresses en mémoire sont connues)

Nous allons maintenant lui ajouter des instructions de saut conditionnels (et, tant qu’on y est, inconditionnels)

4.1 Flags (ou drapeaux...)

Chaque opération (logique ou arithmétique) va positionner deux signaux appelés Flags (ou drapeaux) devant être mémorisés pour l’instruction suivante.

Ces drapeaux ne doivent être modifiés que si on modifie l’accumulateur. Ils sont nommés:

• C (comme carry) :
  • mis à 1 si l’opération courante est une opération arithmétique et donne lieu à une retenue,
  • mis à 0 si l’opération courante est une opération arithmétique et ne donne pas lieu à une retenue,
  • mis à 0 si on fait un load
• Z (comme zéro) :
  • mis à 1 si on charge 0 dans l’accumulateur
  • mis à 0 dans tous les autres cas.

Question 6: Implémenter la gestion des drapeaux, et rajouter deux opérations ADDC et SUBC, prenant en compte la retenue C de l’opération précédente (pour implémenter des additions / soustractions sur des grands nombres par exemple).

4.2 Sauts

Pour implémenter les sauts, on définit trois instructions supplémentaires :

• JMP : saut inconditionnel.
  L’exécution de cette instruction fait sauter l’exécution du programme directement à une adresse donnée (passée comme opérande).
• JNC : saut si C est nul.
  Idem à JMP, mais seulement si C est nul. Sinon, équivalent à NOP (on continue à l’adresse suivante)
• JNZ : saut si Z est nul.
  Idem à JMP, mais seulement si Z est nul. Sinon, équivalent à NOP (on continue à l’adresse suivante)

Question 7: Modifier l’architecture du processeur pour implémenter les sauts.

Tant qu’on y est, pour disposer de pauses, on définit l’instruction NOP, qui ne fait rien.

Question 8: Comment l’implémenter de façon simple ?

On ajoute aussi deux instructions, de rotation de bits (vers la droite ou vers la gauche en incluant le bit de retenue) :

• ROL : ACC[7:0] devient ACC[6:0],C et C devient ACC[7]
• ROR : ACC[7:0] devient C, ACC[7:1] et C devient ACC[0]

De plus, pour tester ce processeur lors du TP, on ajoute un port de sortie : c’est un ensemble de broches dont on veut pouvoir piloter l’état (passer certaines d’entre elles à l’état haut ou bas). Pour nous, il s’agit de piloter un buzzer, donc une seule sortie suffira.

Le jeu d’instruction devient donc (tableau 1.4) :

Remarques :

• AD est le deuxième octet (en RAM) de l’instruction
• (AD) est la valeur en RAM stockée à l’adresse AD

Question 9: Finir le processeur…

Question 10: Certaines opérations peuvent s’exécuter en moins de cycles. Lesquelles, en combien de cycles ? Modifier le processeur de façon à optimiser son temps de fonctionnement.

Question 11: Partant du principe que certaines opérations n’ont pas besoin d’opérande (NOP, ROT, ROR), pourquoi ne pas réduire la taille du code en RAM ?

Question 12 : On veut non seulement augmenter le nombre de sorties, disons à 16, mais aussi à pouvoir utiliser certaines d’entre elles non pas comme des sorties mais comme des entrées. Et ce, de façon dynamique : au cours du programme, une broche peut devenir un sortie, puis une entrée, puis une sortie etc. Comment l’implémenter?

Question 13: Comment modifier le processeur pour supporter une taille mémoire de 161024 mots (10 bits) ?

Dans la prochaine séance, nous construirons d'une manière pratique le nanoprocesseur. Pour préparer cette séance, attardons nous sur son jeu d'instruction et la notion de langage assembleur.

Le jeu d'instruction du nanoprocesseur

Le jeu d'instruction exact du processeur que nous étudierons est accessible à la page suivante:  Le jeu d'instructions du nanoprocesseur

Prenons la peine, d'examiner en détail ce jeu d'instruction, et l'usage qui peut être fait de chaque instruction.

Le langage assembleur

Dans les différentes étapes, nous avons eu l'occasion de décrire des programmes simples pouvant être exécutés par le nanoprocesseur. La version humainement lisible de tels programmes s'appelle le "langage assembleur". Ce type de langage est propre à chaque type de processeur puisque directement dépendant caractéristiques des processseurs. Néamoins tous les langages assembleurs ont un certain nombre de caractéristiques communes. Dans notre cas, les caractéristiques sont les suivantes

1. Chaque ligne correspond à une instruction
2. Chaque ligne comprend plusieurs champs:
   1. Une étiquette éventuelle permettant d'associer un mnémonique à une adresse particulière dans un programme.
   2. Le mnémonique de l'instruction
   3. L'adresse de l'argument de l'instruction, qui peut être elle même représentée par un mnémonique, un nombre, ou éventuellement une expression arithmétique simple
3. Enfin, pour définir des zones de données, nous disposons d'une "directive" (.db pour define byte)

Ainsi, écrit, un tel langage peut être traité automatiquement pour générer le code binaire du programme devant être traité par le nanoprocesseur. 

Prenons la peine d'examiner tout d'abord  le programme de test du nanoprocesseur qui teste chacune des instructions, ainsi que le programme musical qui servira à la démonstration finale.

Voici les réponses aux différentes questions