Différences

Ci-dessous, les différences entre deux révisions de la page.

--- nsi:premiere:architecture:machine_von_neumann [2022/04/07 17:03] – goupillwiki
+++ nsi:premiere:architecture:machine_von_neumann [2023/04/19 23:29] (Version actuelle) – [Unité arithmétique et logique] goupillwiki
@@ Ligne 20: / Ligne 20: @@
    * 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)
-   * **RD** signifie que la mémoire écrit son contenu sur le **BUS**.
+   * **sel** permet d'activer la mémoire, soit en lecture soit en écriture
-   * **WR** signifie que la mémoire lit sur le **BUS**
+   * **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 =====
@@ Ligne 39: / Ligne 39: @@
 Par ailleurs l'UAL transmet des informations sur ACC :
-  * si UAL = 0
+  * si ACC = 0
-  * si UAL > 0
+  * si ACC > 0
 <WRAP tip>Pour l'éventualité de nombres négatifs, on utilise le [[nsi:premiere:ca2|CA2]].</WRAP>
@@ Ligne 48: / Ligne 48: @@
 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 un choix souvent fait mais il complique les choses car il faut lire à chaque fois deux données mémoires.</WRAP>
+<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 :
@@ Ligne 57: / Ligne 57: @@
   * **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 l ''101#####''\\ ''#####'' représente le nouveau numéro de ligne
+  * **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
+  * **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
+  * **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>
+A 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
+</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 =====
-==== Quelques définitions ====
+{{ :nsi:premiere:architecture:uc.png?direct&400 |}}
-  * Les données ne sont pas de simples bits. On les regroupe en mots -- en général 1 octet, 2 octets, ... 8 octets en 64 bits.
+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.
-  * Une unité de mémoire contenant un mot est un **registre**.
-  * On nomme **UC** l'unité de commande chargée de séquencer tous les échanges permettant l'exécution.
+Vous pouvez constater que l'UC pilote tous les organes avec les signaux RD, WR...
-  * On nomme **UAL** l'unité arithmétique et logique qui exécute les calculs.
-  * Le pointeur de ligne, **PL** ou parfois **PC** (//program counter//) est un registre permettant de savoir où on en est du programme.
-  * Le registre instruction **RI** contient l'instruction en cours d'exécution.
-  * Le registre d'adresse **R@** contient l'adresse de la case mémoire en cours d'utilisation.
-  * Le **Bus** est le faisceau de câbles reliant les différents organes et permettant de transporter les données d'un point à un autre.
 ==== Cycle instruction ====
-  * Le
+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>
+A 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
+</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>