GoupillWiki

Cette page est en lecture seule. Vous pouvez afficher le texte source, mais ne pourrez pas le modifier. Contactez votre administrateur si vous pensez qu'il s'agit d'une erreur.
====== Fonctionnement d'une machine de Von Neumann ======

<WRAP tip>Les principes évoqués ici sont valables pour différentes sortes de machines programmables. La machine programmable que nous allons envisager adopte l'[[https://fr.wikipedia.org/wiki/Architecture_de_von_Neumann|architecture de Von Neumann]]. En dépit des nombreuses améliorations et complexifications depuis 1945, le principe général utilisé dans les microprocesseurs d'aujourd'hui reste le même.</WRAP>

<WRAP tip>D'autres architectures existes. L'architecture de Von Neumann se caractérise par le fait que le programme et les données sur lesquelles s'exécutera le programme se trouvent dans une même mémoire. Dans [[https://fr.wikipedia.org/wiki/Architecture_de_type_Harvard|l'architecture Harvard]], il y a une mémoire pour le programme et une mémoire pour les données. Autrement les principes généraux sont semblables.</WRAP>

Dans ce TD nous allons travailler sur un exemple. Les choix que nous ferons seront très simplifiés par rapport à une machine réelle. Mais les principes rencontrés sont valables. Une vraie machine contient seulement beaucoup plus de circuits, beaucoup plus de connexions et on y ajoute tout un tas d'astuces pour optimiser les performances.

Dans ce [[nsi:premiere:architecture:architecture_sequentielle|cours]], nous avons étudié comment, à partir de simples circuits logiques, fabriquer une mémoire, orienter des données sur un bus, produire des séquences de signaux. Nous allons pousser tout cela un peu plus loin ici.

Nous utiliserons [[logiciels:logisim|Logisim]]. Vous pourrez toujours entrer dans les circuits pour voir ce qu'ils contiennent.

===== Choix de la taille des données =====

{{ :nsi:premiere:architecture:memoire.png?direct&400 |}}

La mémoire contient les données et le programme. Ici nous choisissons :

   * Des données sur 8 bits,
   * Des adresses sur 5 bits également -- Nous n'aurons donc que $2^5 = 32$ octets en mémoire !
   * La mémoire comme toute la machine est cadencée par une horloge **CLK**.\\ Les changements opèrent quand CLK a un **front montant** (passe de 0 à 1)
   * **sel** permet d'activer la mémoire, soit en lecture soit en écriture
   * **ld** met la mémoire en lecture (Mémoire vers **BUS**). ld = 0, signifie qu'on est dans l'autre sens (BUS vers mémoire)

===== Unité arithmétique et logique =====

L'**UAL** est le circuit qui fait les calculs. On attend d'un microcontrôleur qu'il sache faire des calculs comme l'addition, la soustraction, le OU, le ET, le NON. Un composant plus performant comme un microprocesseur pourra en faire plus, comme la multiplication.

{{ :nsi:premiere:architecture:ual.png?direct&400 |}}

Notre UAL contient un registre **ACC** -- //Accumulateur//. Tous les calculs stockent leur résultat dans ACC. Il contient également un registre temporaire **W** -- //Work//.

Voici ce que sait faire notre UAL :
  * **WR :** Lit le BUS et l'écrit dans W,
  * **ADD :** additionne les valeurs de W et ACC et stocke le résultat dans ACC,
  * **SUB :** calcule ACC - W et stocke le résultat dans ACC,
  * **LD :** (//LOAD//) charge W dans ACC
  * **RD :** écrit ACC sur le BUS

Par ailleurs l'UAL transmet des informations sur ACC :
  * si ACC = 0
  * si ACC > 0

<WRAP tip>Pour l'éventualité de nombres négatifs, on utilise le [[nsi:premiere:ca2|CA2]].</WRAP>

===== Jeu d'instructions =====

On définit ce que notre machine saura faire. Pour chaque instruction, l'unité de commande (**UC**) devra savoir quoi faire.

<WRAP tip>Les données en mémoire font 1 octet = 8 bits. On pourrait faire 2 lectures pour obtenir un mot de 2 octets = 16 bits. C'est le choix qui est fait en général pour les composants réels. Ici nous choisissons la simplicité ce qui nous met un peu à l'étroit ! Néanmoins, avec ces 8 instructions, nous pourrons déjà écrire des programmes.</WRAP>

Nous choisissons qu'une instruction **fera toujours 1 octet**. Voici les instructions que nous voulons avoir :

  * **HLT :** //halt//, le programme s'arrête.\\ code : ''000xxxxx''
  * **ADD :** //addition//, l'UC demande une addition à l'UAL.\\ code : ''001@@@@@''\\ ''@@@@@'' représente l'adresse d'une case mémoire. Le contenu de cette case est chargé dans W de UAL.
  * **SUB :** //soustraction//, l'UC demande une soustraction.\\ code : ''010@@@@@''
  * **LDA :** //chargement//, l'UC demande de charger une valeur de la mémoire dans ACC\\ code : ''011@@@@@''
  * **STO :** //stockage//, l'UC demande l'écriture de ACC dans un case mémoire\\ code : ''100@@@@@''
  * **BRA :** //branchement//, l'UC change la valeur de la ligne d'exécution en cours\\ code : ''101#####''\\ ''#####'' représente le nouveau numéro de ligne
  * **BRZ :** //branchement si zéro//. Même chose que le précédent mais à condition que ACC = 0\\ code : ''110#####''
  * **BRP :** //branchement si positif//. Même chose que le précédent mais à condition que ACC > 0\\ code : ''111#####''

<WRAP tip>Sans les deux dernières instructions, un programme ferait toujours la même suite d'instruction. Ces deux instructions sont comme des ''if''.</WRAP>

<WRAP box>===Questions ===
La mémoire contient :\\ //écrit en hexadécimal, octets séparés par un espace//
<code lang-none>
6A 2B 8C 00 00 00 00 00   00 00 05 03 00 00 00 00
00 00 00 00 00 00 00 00   00 00 00 00 00 00 00 00
</code>
  - Y a-t-il un moyen de savoir quelles cases correspondent aux instructions d'un programme ?
  - Les 4 premiers octets sont les  instructions d'un programme.\\ Écrivez ces octets en binaire puis traduisez-les selon le code définit plus haut.
  - Que fait ce programme ?
</WRAP>

===== Les registres =====

{{ :nsi:premiere:architecture:machine.png?direct&600 |}}


En plus des registres W et ACC dans l'UAL, nous utiliserons 3 registres très importants :
  * Registre d'adresse **R@** : contient l'adresse de la case mémoire en cours de lecture.
  * Registre instruction **RI** : contient l'instruction en cours d'exécution.
  * Pointeur de ligne (//Program Counter//) **PC** : contient le numéro de la prochaine ligne programme\\ Cette ligne correspond à la case mémoire de même numéro.\\ Comme le fonctionnement basique est de passer à la ligne suivante, ce registre est doté d'une commande +1.

===== Cycle instruction =====

{{ :nsi:premiere:architecture:uc.png?direct&400 |}}

L'unité de commande (**UC**) se charge, en fonction de l'instruction en cours, de produire la suite de signaux nécessaires à l'exécution de cette instruction.

Vous pouvez constater que l'UC pilote tous les organes avec les signaux RD, WR...

==== Cycle instruction ====

Le graphique ci-dessous décrit la totalité du fonctionnement de l'UC.

{{ :nsi:premiere:architecture:etats.svg |}}

=== Comment lire ce diagramme ===

Ce diagramme décrit une **machine à état**. Chaque cercle jaune représente un état.
  * L'UC commence dans l'état 0,
  * à chaque front d'horloge, l'état change selon les chemins (//transitions//) représentés par les flècles,
  * dans certains cas, plusieurs chemins quittent un état. La machine emprunte alors le seul chemin possible selon le cas (//des conditions sont précisées surs ces transitions//)
  * dans les états, on précise ce que doit faire la machine.\\ Par exemple, dans l'état 1 il faut faire le transfert MEM -> RI et aussi incrémenter PC (//faire +1//)
  * Pour mémoriser l'état dans lequel est la machine, on utilise des mémoires. Ici 4 mémoires $Q_3Q_2Q_1Q_0$ suffisent. Par exemple pour l'état 5, on a $Q_3Q_2Q_1Q_0 = 0101$

<WRAP box>=== Questions ===
  - Quel signaux l'UC doit-elle activer pour produire le transfert MEM -> RI ?
  - Dans quels états le signal WR du registre R@ doit-il être activé ?
  - Déduisez-en l'équation logique de ce WR en fonction des $Q_3$, $Q_2$, $Q_1$, $Q_0$.
  - Un peu plus difficile : à quelle condition $Q_3$ doit passer à 1 ?\\ //Pour répondre, constatez que $Q_3$ vaut 1 dans les états 8 et 9 et que l'on active 8 si on est dans l'état 3 et que la commande est STO ou si on est dans l'état 2 et que... je vous laisse finir.//
</WRAP>

<WRAP tip>Ces quelques questions vous montre comment on peut définir les équations logiques de tous les signaux dont nous avons besoin et obtenir les transitions prévues par le schéma. Si nous voulions une UC plus performante avec un jeu d'instruction plus riche, le principe serait le même mais avec une machine à état plus volumineuse.</WRAP>

===== Simulation sur Logisim =====

Chargez {{ .:vonneumann.circ |}} et ouvrez-le avec logisim.

Pour simuler, choisissez l'outil avec la main (en haut à gauche) puis appuyez sur le bouton RESET une fois.

Ensuite, vous ferez avancer la simulation pas à pas en faisant des tops d'horloge. Pour cela vous pouvez par exemple faire **CTRL+T** au clavier ce qui change l'état de l'horloge. La simulation avance chaque fois que l'horloge passe de 0 à 1.

<WRAP box>=== À faire ===
  * Avec l'outil de sélection activé, cliquez-droit sur la mémoire et choisissez //Edit Contents//
  * Entrez dans la mémoire le contenu vu précédemment :<code lang-none>
6A 2B 8C 00 00 00 00 00   00 00 05 03 00 00 00 00
00 00 00 00 00 00 00 00   00 00 00 00 00 00 00 00
</code>
  * Exécutez (comme décrit ci-dessus).\\ Observez que le programme se déroule bien comme prévu, en passant bien par tous les états indiqués par la machine à états.
</WRAP>

<WRAP box>=== Plus gros programme ===

  * Télécharger le fichier {{ :nsi:premiere:architecture:p2.txt |}},
  * dans la mémoire, chargez ce fichier,
  * décodez le contenu de ce programme.\\ En particulier vous devez deviner quelles cases mémoires correspondent à des instructions et quelles cases correspondent à des données utilisées par le programme.
  * Exécutez et vérifiez le bon fonctionnement.
</WRAP>

<WRAP tip>Dans le 2e cas, faire toute l'exécution pas à pas peut être long. Contentez-vous alors de faire quelque pas pour voir ce qui se produit, puis passez en mode automatique en appuyant **CTRL+K**. Quand vous constaterez que la simulation est bloquée sur HLT, ce sera que l'exécution est terminée. Rappuyez alors sur CTRL+K et constatez le résultat en mémoire.</WRAP>