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.

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.

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.

MOV R0,#42
STR R0,150
HALT

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

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 

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.

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.

Les labels

Le simulateur prend en charge les labels.

MOV R0, #4
STR R0,30
MOV R0, #8
STR R0,75
LDR R0,30
CMP R0, #10
BNE else
MOV R0, #9
STR R0,75
B endif
else:
LDR R0,30
ADD R0, R0, #1
STR R0,30
endif:
MOV R0, #6
STR R0,23
HALT

Voici un programme Python :

x = 0
while x<3:
   x = x+1

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