Le microprocesseur d’une machine est constitué de circuits électroniques, chacun d’entre eux fonctionnant selon un mode dit « tout ou rien » : à un instant donné il se trouve soit dans un état ouvert : le courant électrique ne passe pas, ce qui sera représenté par le chiffre « zéro », soit dans un état fermé : le courant électrique passe, ce qui sera représenté par le chiffre « 1 ».
En d’autres termes, ces circuits ne peuvent fonctionner qu’à partir d’une représentation binaire des données à traiter mais aussi des instructions à exécuter.
Comment dans ces conditions un programme écrit dans un langage comme Python peut-il être exécuter par un microprocesseur ?
Objectifs
Connaissances visées
Savoir définir les notions d’interprétation et de compilation d’un code source. Savoir différencier un langage de haut niveau comme Python d’un langage assembleur et du langage machine. Connaître la structure d’une instruction en langage machine.Compétences à développer
Dérouler l’exécution d’une séquence d’instructions simples du type langage machine. Écrire un programme simple en langage comparable à un assembleur dans un simulateurLangage de haut niveau et langage machine
Compilation, Interprétation du code source
Langage Assembleur : principe
Langage Assembleur : Simulation du fonctionnement d’un CPU
Ce Qu’il Faut Retenir (CQFR)… (donc apprendre !)
Langage de haut niveau et langage machine
Un langage de haut-niveau est un langage ‘proche’ dans son vocabulaire d’un langage humain (« for » « while », « if », « else ») et qui fait appel à des symboles mathématiques (« = », « + »,), compréhensible par un humain.
Un programme écrit dans un langage de haut-niveau s’appelle un « code-source ».
Un tel programme ne peut pas être exécuté directement par le processeur d’une machine. Il est incompréhensible pour un processeur.
Compilation, Interprétation du code source
Afin de pouvoir faire exécuter par le processeur un programme écrit dans un langage de haut niveau il faut en effectuer une « traduction » en langage machine
Il existe deux voies de « traduction » : la compilation et l’interprétation.
Dans un cas comme dans l’autre, cette traduction est effectuée par un programme (logiciel, application). Dans le premier cas il s’agit d’un programme appelé « compilateur » et dans le deuxième cas d’un programme appelé « interpréteur ».
Dans le cas d’un code source compilé, le compilateur effectue la totalité de la traduction, puis produit un rapport qui signale les éventuelles erreurs de syntaxe rencontrées. Après correction de ces erreurs, la totalité du code source doit être recompilée. Une fois le programme totalement compilé et ne présentant plus d’erreurs de syntaxe, le code écrit en langage machine est sauvegardé dans un fichier. Sous (c)MS Windows ces fichiers le nom de ces fichiers se termine par l’extension « .exe » ou « .bin ».
En cas de modification du programme – corrections, améliorations, ajouts – la totalité di code source doit être recompilée et sauvegardée dans un fichier.
En revanche, quand on veut exécuter le programme, la totalité de celui-ci peut être chargée en RAM, et est aussitôt « disponible » pour le processeur.
Exemple de langages compilés : C++, Pascal
Dans le cas d’un code source interprété, l’interpréteur traduit le programme petit à petit, « ligne après ligne » et charge le code traduit en langage machine en RAM au fur et à mesure afin qu’il soit exécuté par le processeur.
S’il rencontre une erreur de syntaxe, l’interpréteur s’arrête et le plus souvent affiche un message d’erreur. Après correction de l’erreur, la traduction du code source reprend depuis le début.
Exemples de langages interprétés : Python, javascript, php.
Langage Assembleur
Le langage Assembleur est un langage de bas niveau. Les instructions écrites en langage Assembleur sont très proches de celles du langage machine, donc très rapidement traduites.
Comment est construite une instruction en Langage Assembleur ?
Lorsqu’on lance l’exécution d’un programme écrit en Python, les instructions sont traduites dans un langage intermédiaire appelé « bytecode ».
Ce langage est comparable (mais différent) à du « langage machine».
Une bibliothèque permet de récupérer le bytecode de le transformer en « instructions » comparables à celle d’un langage Assembleur.
Dans un éditeur/interpréteur de langage Python, ouvrir le fichier « def_test.py » et examiner le code de ce programme.
Dans ce programme se trouve une fonction ‘test()’ et d’autres instructions qui font appel au module ‘dis’.
En exécutant ce programme les instructions de la fonction ‘test()’ vont être traduite en « bytecode » et le module ‘dis’ va nous permettre de récupérer une version ‘lisible’ de ce « bytecode » et de l’afficher.
Lancer l’exécution du programme « def_test.py »
Il s’agit de mettre en correspondance d’une part les instructions écrite en Python (langage de haut-niveau) et d’autre part les « opérations élémentaires » du « bytecode » (langage de bas niveau, comparable à un langage Assembleur).
Dans un traitement de texte, réalisez un tableau à deux colonnes comme celui qui suit et complétez la colonne de droite.
| Instructions « Python » de la fonction ‘test()’ | Instructions (Opérations + opérandes) « bytecode » correspondantes |
x = 3 | LOAD_CONST 100 | 1 3 |
y = 5 | |
x = (x * y) + x | |
z = x / 2 | |
return z |
En langage Assembleur , une instruction est composée :
d’une opération, définie par un nom (moyen mnémotechnique pour le programmeur) et d’un code (seule information nécessaire au processeur ; suivie d’opérandes, dont le nombre varie le plus souvent entre 0 et 2 ; il peut s’agir de valeurs ou d’adresses en RAM
<< Cliquez pour plus d’informations <<Simulation du fonctionnement d’un CPU
Démarrez l’exécution du programme « Johnny ».
Il s’agit d’un programme qui permet de simuler le fonctionnement d’un CPU.
L’interface graphique comporte 3 parties :
- à gauche se trouve ce qui correspond à la RAM
- au centre se trouve ce qui correspond à l’Unité de Contrôle (UC)
- et à droite se trouve ce qui correspond à l’Unité Arithmétique
et Logique (UAL)
Pour visualiser le contenu détaillé de l’UC, cliquez sur ce bouton (ci-contre) :
Le CPU simulé ici possède un jeu d’instructions très réduit que voici :
TAKE La valeur de l'emplacement pointé par l'adresse absolue est copiée dans l'accumulateur.
SAVE La valeur de l'accumulateur est copiée à l'emplacement pointé par l'adresse absolue.
ADD La valeur de l'emplacement pointé par l'adresse absolue est ajoutée à la valeur de l'accumulateur.
SUB La valeur de l'emplacement pointé par l'adresse absolue est soustraite à la valeur de l'accumulateur.
INC La valeur de l'emplacement pointé par l'adresse absolue est incrémentée.
DEC La valeur de l'emplacement pointé par l'adresse absolue est décrémentée.
NULL La valeur de l'emplacement pointé par l'adresse absolue est mise à zéro.
TST Si et seulement si la valeur de l'emplacement pointé par l'adresse absolue est nulle, l'instruction suivante est ignorée.
JMP Le programme se poursuit à l'adresse fournie.
HLT Le simulateur affiche un message qui signale que l'exécution du programme est terminée.Le programme suivant additionne 2 nombres rangés aux adresses <10> et <11>, et mémorise le résultat à l’adresse <12> :
000: | TAKE | 010 |
001: | ADD | 011 |
002: | SAVE | 012 |
003: | HLT | 000 |
Saisie de ce programme dans le simulateur
Pour cela double-cliquez d’abord sur l’emplacement de la RAM dont l’adresse est « 000 ».
Une petite fenêtre s’ouvre.
Dans la colonne « hi », cliquez sur la sélection déroulante, puis choisissez l’instruction voulue (‘TAKE’).
Puis dans la colonne « lo » (partie jaune) entrez la valeur de l’opérande (‘010’)
Validez en cliquant sur le bouton ‘RAM’
Procédez de la même manière pour les autres instructions.
Puis entrez seulement deux valeurs aux adresses ‘010’ et ‘011’ de la RAM
Lancement de la simulation
Pour cela utiliser les boutons suivants :
 | Pour réinitialiser la simulation |
 | Pour lancer la simulation en mode pas-à-pas : à chaque clic, le programme avance d’une ligne |
 | Pour lancer la simulation du programme, du début jusqu’à la fin. |
Observez ce qui se passe au niveau des registres de l’UC et de l’accumulateur de l’UAL.
Le programme qui suit permet de multiplier deux nombres rangés aux adresses <10> et <11>, et mémorise le résultat à l’adresse <12>
La multiplication de deux nombres est ici mise en œuvre en additionnant de manière répétitive le nombre rangé à l’adresse <10> au résultat à l’adresse <12> dont la valeur initiale est nulle.
A chaque itération, la valeur stockée à l’adresse <11> est décrémentée. L’itération se poursuit jusqu’à ce que la valeur à l’adresse <11> soit nulle.
000: | NULL | 012 |
001: | TAKE | 012 |
002: | ADD | 010 |
003: | SAVE | 012 |
004: | DEC | 011 |
005: | TST | 011 |
006: | JMP | 001 |
007: | HLT | 000 |
Entrez ce programme dans le simulateur et lancez la simulation.
Enfin, traduire les deux petits programmes qui suivent écrits en langage Python, en langage Assembleur de “Johnny” puis les exécuter.
Programme 1
x = 5
y = 8
x = ((x * 2) + (y * 3))
Programme 2
x = 8
y = 4
x = (x * 3) / y