Démonstration (vidéo - du début à 3:30)

Une excellente explication des bases du fonctionnement se trouve dans la vidéo de Computerphile, notamment les trois premières minutes et demi.

Explication des instructions de bas niveau

Quelques points clés :

• chaque donnée, incluant les instructions, se trouve à une adresse spécifique en mémoire vive
• les instructions font toujours référence à l’adresse en mémoire et non à la valeur qu’elle contient; certaines instructions demandent de lire la valeur à cet endroit et d’autres demandent d’écrire une nouvelle valeur à cet endroit
• il y a des adresses spécialisées sur le processeur pour stocker des valeurs à court terme durant les opérations - les registres de l’unité d’arithmétique et de logique
• il y a un registre spécial qui stocke toujours l’adresse de la prochaine instruction à exécuter - le compteur du programme; certaines opérations modifient directement cette valeur, sinon l’adresse avance par un nombre de bits spécifique correspondant à la largeur des cellules en mémoire.

Ce qui n’est pas mentionné dans la vidéo mais qui est également important :

• S’il y a des données que vous voulez utilisez en référence durant le programme ou conserver par la suite, il doit avoir des adresses en mémoire pour ces valeurs au delà des registres de l’UAL (qui seront réutilisés pour d’autres opérations)
• On montre les instructions utilisant des mots qu’on peut lire et des nombres décimaux : Cela correspond au langage assembleur ou à un autre langage de bas niveau. Ces instructions seraient traduits en binaire (langage machine) pour l’exécution :
  • un code unique par mot-clé, chaque code correspondant à un circuit qui existe dans le processeur
  • toutes les valeurs sont en binaire
  • un format standard pour l’instruction, p. ex. 1 octet pour le code d’instruction et, selon l’instruction, des nombres spécifiques d’octets pour la 1e opérande et pour la 2e opérande.

Langages de bas niveau

Quand tout est en binaire (les codes d’opération et les opérandes), le code s’appelle le langage machine. Les 1 et 0 opèrent directement sur les circuits de l’ordinateur (les portes logiques et composants vus précédement).

Quand on remplace le code d’opération avec un mot-clé et on écrit les adresses avec des caractères (p.ex.: r1, 0x0004), le code s’appelle un langage assembleur. Il est équivalent au langage machine, mais lisible par les humains.

Ce sont les deux langages de bas niveau. Les opérations sont contraintes à représenter directement les circuits de la machine. Les langages de haut niveau n’ont pas cette contrainte.

Langages de haut niveau

Avec les langagages de haut niveau, on peut se permettre d’utiliser des mots-clés et des structures plus naturelles pour les humains sachant que ces instructions seront analysés par un logiciel (l’interpréteur ou le compilateur) qui les traduira en langage machine (ou produira des messages d’erreur si les instructions ne sont pas valides).

On trouve dans la plupart des langages de haut niveau des mot-clés comme : if-else (si, sinon), for (pour les éléments ou valeurs suivants), while (tant que la condition suivante est vraie), etc. Chacun de ces mots-clés seraient remplacé par toute une série de codes d’opération en langage machine.

Comparaison des différents types de programmes

Voici une comparaison de programmes écrites en trois version présumant les informations suivantes :

• le code 0b0001 = 0x1 = 1 est l’opération d’enregistrement d’une valeur en mémoire dans le registre r1
• le code 0b0010 = 0x2 = 2 est l’opération d’ajout d’une valeur à celle déjà dans le registre r1
• le code 0b0011 = 0x3 = 3 est l’opération de stockage d’une valeur à une adresse en mémoire vive
• la valeur 0b00011011 = 0x1b = 27 est une adresse en mémoire vive qui contient la valeur 2 (0b10 = 0x2)
• la valeur 0b00011100 = 0x1c = 28 est une adresse en mémoire vive qui contient la valeur 3 (0b11 = 0x3)

Le but du programme est d’ajouter les valeurs 2 et 3 et le stocker en mémoire à l’adresse 0x1d.

0b0001 0b00011011
0b0010 0b00011100
0b0011 0b00011101

Load r1, 0x1b
Add r1, 0x1c
Store r1, 0x1d

n = 2 + 3