Simulateur de CPU

Ce simulateur, basé sur une architecture de von Neumann, est composé d’un CPU et d’une mémoire.

source : https://www.peterhigginson.co.uk/AQA/

Présentation

Il est relativement facile de distinguer les différentes parties du simulateur :

  • à droite, la mémoire vive ou RAM (Main Memory) ;
  • au centre, le microprocesseur (avec ses différentes composantes : ALU, CU, registres, …) ;
  • à gauche, la zone d’édition (Assembly Language), permettant de saisir des programmes en assembleur.

 


La RAM

Le contenu des différentes cellules de la mémoire peut être affiché dans différents formats :

  • base 10 (entier signé, signed) – par féfaut
  • base 10 (entier non-signé, unsigned),
  • base 16 (hex),
  • base 2 (binary).

On peut modifier le format d’affichage de la mémoire à l’aide du bouton OPTIONS situé en bas dans la partie gauche du simulateur.

À l’aide du bouton OPTIONS, passer à un affichage en binaire.

 

 

Chaque cellule de la mémoire est accessible par son adresse. Il existe deux formats d’adressage des cellules de la mémoire :

  • 32 bits – format mot (option word mode) – par féfaut
    les adresses vont de
    000 à 199 (codée en base 10).
  • 8 bits – format octet (option byte mode)
    les adresses vont de 000 à 799 (codée en base 10).

On peut modifier le format d’adressage de la mémoire à l’aide du bouton OPTIONS.

Régler la mémoire de sorte d’avoir un affichage hexadécimal, avec des cellules au format 32 bits.

 

 

 


Le CPU

Dans la partie centrale du simulateur, on trouve les différent composants du microprocesseur :

  • les registres (Registers) : 13 registres (R0 à R12)
  • 1 registre spécial (PC) qui contient l’adresse mémoire de l’instruction en cours d’exécution ;
     
  • l’unité de commande (Control Unit) qui contient l’instruction machine en cours d’exécution (au format hexadécimal)
  • l’unité arithmétique et logique (Arithmetic and Logic Unit)
  •  …

 

Programmer en assembleur

La zone d’édition (Assembly Language) permet de saisir des programmes en assembleur.

Dans la zone d’édition (Assembly Language) saisir les lignes de codes suivantes :

puis cliquer sur le bouton Submit.

Le programme vient d’être mis dans les cellules mémoires d’adresses 000, 001 et 002 :

L’assembleur a converti les 3 lignes du programme en instructions machines, chacune occupant une cellule de 32 bits :

  • adresse 000 : MOV R0,#42
  • adresse 001 : STR R0,150
  • adresse 002 : HALT
Identifier la valeur 42 dans la mémoire
Pour avoir une idée des véritables instructions machines, repasser à un affichage en binaire (OPTIONS / binary)) pour obtenir ceci :

On constate que chaque instruction machine occupe un mot (32 bits) et correspond à une ligne de code en assembleur :

  • 11100011 10100000 00000000 00101010 correspond au code assembleur MOV R0,#42 
  • 11100101 10001111 00000010 01001100 correspond au code assembleur STR R0,150 
  • 11101111 00000000 00000000 00000000 correspond au code assembleur HALT 

 

Repasser à un affichage en hexadécimal afin de faciliter la lecture des données présentes en mémoire.

 

Simulation

Pour exécuter un programme, il suffit de cliquer sur le bouton RUN (exécution en continu) ou STEP (exécution pas à pas).

Par défaut, le simulateur montre comment il « travaille » par une animation. La vitesse d’animation est réglable à l’aide des boutons << et >> apparaissant à coté du bouton STOP qui permet de mettre l’exécution en pause :

ATTENTION : pour relancer la simulation, il est nécessaire d’appuyer sur le bouton RESET ou ASSEMBLE afin de remettre les registres à zéro, et en particulier le registre PC permettant à l’unité de commande de pointer de nouveau sur l’instruction située à l’adresse mémoire 000.

Tester l’exécution du code, en ralentissant suffisamment la vitesse afin de bien comprendre toutes les étapes de cette exécution. .

On constate que deux types de valeurs circulent au sein du système :

  • des données (valeurs lues/écrites de/vers la mémoire/les registres/l’unité de commande)
  • des adresses des cellules de mémoire

 

Une fois la simulation terminée, on peut constater que la cellule mémoire d’adresse 150, contient bien le nombre 42 (en base 10). il en est de même pour le registre R0.

Pour remettre la mémoire à 0, il faut cliquer sur le bouton OPTIONS et choisir clr memory.

 

Modifier le programme précédent pour qu’à la fin de l’exécution on trouve le nombre 54 à l’adresse mémoire 50. On utilisera le registre R1 à la place du registre R0. Tester les modifications en exécutant la simulation.

 

Les labels

Le simulateur prend en charge les labels.

Saisir et tester le programme suivant :

 

Voici un programme Python :

Écrire et tester un programme en assembleur équivalent au programme ci-dessus.

 

source : https://pixees.fr/informatiquelycee/n_site/nsi_prem_sim_cpu.html

Vous aimerez aussi...

Laisser un commentaire

Votre adresse de messagerie ne sera pas publiée. Les champs obligatoires sont indiqués avec *

*

code