Exprimer un algorithme dans un langage de programmation a pour but de le rendre exécutable par une machine dans un contexte donné. La découverte de l’architecture des machines et de leur système d’exploitation constitue une étape importante.

• Contenus : Modèle d’architecture séquentielle (von Neumann)
• Capacités attendus : Distinguer les rôles et les caractéristiques des différents constituants d’une machine. Dérouler l’exécution d’une séquence d’instructions simples du type langage machine.
• Commentaires : La présentation se limite aux concepts généraux. On distingue les architectures monoprocesseur et les architectures multiprocesseur. Des activités débranchées sont proposées. Les circuits combinatoires réalisent des fonctions booléennes.

Architecture de Von Neumann

Architecture de référence

L'architecture générale des ordinateurs a été développée dans le cadre d'un projet EDVAC par John Von Neumann (et d'autres scientifiques de l'époque), mathématicien et physicien américano-hongrois en 1945. Ce modèle propose une structure dans laquelle le programme est stocké dans la mémoire de la machine. On parle maintenant de modèle de Von Neumann.

L’architecture de von Neumann décompose l’ordinateur en 4 parties distinctes :

• l’unité arithmétique et logique (UAL ou ALU en anglais) ou unité de traitement : son rôle est d’effectuer les opérations de base ;
• l’unité de contrôle, chargée du « séquençage » des opérations : elle joue un rôle de coordonnateur ;
• la mémoire qui contient à la fois les données et le programme qui indiquera à l’unité de contrôle quels sont les calculs à faire sur ces données. La mémoire se divise entre mémoire volatile (programmes et données en cours de fonctionnement) et mémoire permanente (programmes et données de base de la machine) ;
• les dispositifs d’entrée-sortie, qui permettent de communiquer avec le monde extérieur.

L'unité de commande et l'unité arithmétique et logique forment l'unité centrale ou l'unité de commande ou plus communément le processeur.

UAL

L'unité arithmétique et logique est le cœur de l'ordinateur. On la représente habituellement par ce schéma (en forme de V) :

source : wikipedia

• A et B sont les opérandes (les entrées)
• R est le résultat (de taille fixe)
• F est une opération binaire (opération arithmétique comme une addition, logique comme un ou-exclusif ou de comparaison comme un test d'égalité, ...)
• D est un drapeau indiquant un résultat secondaire de la fonction (un signe, une erreur de dépassement, une retenue, ...)

Mémoire

Voici ci-dessous une représentation d'une mémoire où les adresses sont codées sur 4 bits et les valeurs sur 8 bits.

À l'adresse X$=0000$ de la mémoire est stocké le nombre entier 161 écrit en binaire, d'où la valeur : #X$=10100001$.

Processeur

Le processeur, appelé aussi unité de commande ou unité centrale, dirige le fonctionnement de tous les autres éléments de l'ordinateur.
Outre divers éléments comme une horloge servant à synchroniser différents éléments du processeur, l'unité de commande comporte un ensemble de registres spécialisés qui ne peuvent contenir qu'un type précis de données.
Parmi ces registres, nous allons utiliser les trois suivants :

• CO : le compteur ordinal ; il contient l'adresse de la prochaine instruction à exécuter ;
• RI : le registre d'instruction ; il contient l'instruction en cours ;
• ACC : l'accumulateur ; registre de l'UAL chargé de stocker une des opérandes avant l'exécution puis le résultat de l'opération.

On peut résumer le fonctionnement du processeur par l'algorithme suivant :

Tant que CO contient des instructions : 
    RI reçoit de la mémoire l'instruction dont l'adresse est contenue dans CO
    L'instruction chargée dans RI est exécutée.
    CO est incrémenté de la longueur de l'instruction traitée pour permettre d'accéder à l'instruction suivante

Assembleur

Comme ces successions de bits sont très peu gérables par un humain, un langage de programmation de bas niveau est nécessaire :

En langage assembleur, on peut rencontrer :

1. des calculs simples (addition, soustraction, multiplication, ...),

2. des affectations (placer telle valeur de la mémoire vive dans tel registre et vice versa)

3. des instructions de saut qui permettent de coder des instructions conditionnelles par exemple.

De plus, il y a trois possibilités pour accéder à un opérande (valeur sur laquelle va être opérée une opération) :

• Il est directement saisi
• Il est dans un registre : il faut alors indiquer le nom de ce registre
• Il est dans la mémoire vive : il faut indiquer son adresse.

Exemples d'utilisation de l'assembleur

exercice de renforcement

Simulateur de CPU

Utilisation

Il existe autant de langages machines que de types de processeurs. Les commandes de base sont assez faciles à transposer d'un langage à l'autre.

Par exemple, l'instruction qui permet de copier le contenu d'un registre dans une mémoire donnée par son adresse peut s'appeler suivant les processeurs STO, STR ou STA.

Afin de pouvoir mieux visualiser le fonctionnement d'un processeur et de pouvoir tester ses lignes de code en langage assembleur, nous allons désormais utiliser le simulateur accessible avec ce lien.

Voici un visuel de ce simulateur :

Voici une présentation en vidéo de ce simulateur.

Voici un schéma détaillant les différents éléments de l'architecture de Von Neumann :

Voici une image d'un simulateur de processeur :

1. Repérer dans le simulateur, les différents éléments spécifiques de l'architecture de Von Neumann.

2. Repérer dans le simulateur les éléments suivants :

   • Les registres :
     • PC
     • CIR
     • MAR
   • Les entrées
   • Les sorties
   • L'Unité Arithmétique et Logique
   • L'unité de contôle
   • La mémoire

Correction : L'exercice précédent est corrigé dans la vidéo ci-dessous vidéo :

Voici un nouvel exercice de programmation en asssembleur. Cependant, le jeu d'instructions n'est pas le même que celui de l'exercice 1 car ce jeu correspond désormais à celui du simulateur précédemment présenté ; dans toute la suite du chapitre, c'est ce jeu d'instructions qui sera utilisé.

Voici le tableau d'instructions de ce simulateur :

Instruction	Effet
INP	Lire une valeur à partir de la console d'entrée
OUT	Ecrire une valeur sur la console d'affichage
ADD	Addition
SUB	Soustraction
MOV	Affectation
LDR	Affectation
STR	Affectation
B	Aller à
HALT	Fin du programme
CMP	Comparaison
BEQ	Comparaison (égalité) puis saut à une adresse
BNE	Comparaison (inégalité) puis saut à une adresse
BGT	Comparaison (supérieur) puis saut à une adresse
BLT	Comparaison (inférieur) puis saut à une adresse

• pour les instructions de saut, on donnera un label à la place d'une adresse
• un nombre est précédé d'un # pour le différencier d'une adresse mémoire

Quelques exemples :
• MOV R₀ , #25 : affecte la valeur 25 au registre R₀

  Le nombre 25 est précédé d'un # pour le différencier d'une adresse mémoire.

• CMP R₀ , #15 : compare 15 et la valeur du registre R₀
• BEQ test : saute les lignes pour aller à test si la condition (précédente R₀=15) est vérifiée.

  Pour les instructions de saut, on donne un label, ici test, à la place d'une adresse.

• ADD R₁, R₀, #10 : ajoute 10 à la valeur du registre R₀ et affecte le résultat dans le registre R₁
• LDR R₀, 12 : affecte la valeur stockée à l'adresse 12 dans le registre R₀
• STR R₀, 12 : affecte la valeur stockée dans le registre R₀ à l'adresse 12
• INP R₀, 2 : Lit un nombre et l'affecte à R₀. Le 2 est un paramètre pour typer le nombre
• OUT R₀, 4 : écrit le contenu de R₀. Le paramètre 4 correspond au nombre signé

Vous pouvez obtenir un détail sur le jeu d'instructions de ce simulateur à cette endroit de la page .

1. Observer le programme écrit en langage machine :

   

2. Indiquer la signification de cette suite d’instructions.

3. Quel est le contenu de R0,R1,R2 à la fin de ces instructions ?

4. Que signifie la commande OUT R2,4

Voici une image plus complète du programme dans le simulateur :

Correction : L'exercice précédent est corrigé dans la vidéo ci-dessous vidéo :

exercice de renforcement

Correction : L'exercice précédent est corrigé dans la vidéo ci-dessous vidéo :

INP R0,2
INP R1,2
CMP R1,R0
BGT VRAI
OUT R0,4
B DONE
VRAI:
OUT R1,4
DONE:
HALT
            

exercice de renforcement

MOV R0,#0	
REP:
CMP R0,#4
BLT VRAI
B DONE
VRAI:
ADD R0,R0,#1
B REP
DONE:
OUT R0,4
HALT
            

Jeu d'instructions détaillé

Voici la liste des instructions de ce simulateur, instructions traduites en français :

• LDR Rd, <adresse mémoire> Charge la valeur enregistrée dans l'<adresse mémoire> dans le registre d
• STR Rd, <adresse mémoire> Enregistre la valeur du registre d dans la mémoire spécifiée par <adresse mémoire>
• ADD Rd, Rn, < opérande 2 > ajoute la valeur spécifiée par < opérande 2 > à la valeur du registre d et enregistre le résultat dans le registre d
• SUB Rd, Rn, < opérande 2 > Soustrait la valeur de < opérande 2 > à la valeur du registre n et enregistre le résultat dans le registre d
• MOV Rd, < opérande 2 > Copie la valeur < opérande 2 > dans le registre d
• CMP Rn, < opérande 2 > Compare la valeur de registre n avec la valeur de < opérande 2 >.
• B <label> Branchement inconditionnel jusqu'à la positon <label> dans le programme.
• B <condition> <label> Branchement conditionnel vers la position <label> dans le programme si la dernière comparaison rempli le critère spécifié par <condition>. Les valeurs possibles sont : EQ:égal à ; NE: n'est pas égal à; GT:Plus grand que; LT: Moins grand que.
• AND Rd, Rn, < opérande 2 > Effectue l'opération bit à bit logique AND (ET) entre la valeur du registre n et la valeur < opérande 2 > et enregistre le résultat dans le registre d.
• ORR Rd, Rn, < opérande 2 > Effectue l'opération bit à bit logique OR (OU) entre la valeur du registre n et la valeur < opérande 2 > et enregistre le résultat dans le registre d.
• EOR Rd, Rn, < opérande 2 > Effectue l'opération bit à bit logique XOR(OU exclusif) entre la valeur du registre n et la valeur < opérande 2 > et enregistre le résultat dans le registre d.
• MVN Rd, < opérande 2 > Effectue l'opération bit à bit logique NOT (NON) sur la valeur < opérande 2 > et enregistre le résultat dans le registre d.
• LSL Rd, Rn, < opérande 2 > Décale de < opérande 2 > bit(s) vers la gauche la valeur du registre n et enregistre le résultat dans le registre d
• LSR Rd, Rn, < opérande 2 > Décale de < opérande 2 > bit(s) vers la droite la valeur du registre n et enregistre le résultat dans le registre d
• HALT Arrête l'exécution du programme.

• < opérande 2 > peut être #nnn (c'est à dire un nombre, exemple #42) ou bien Rm (c'est à dire le registre m , par exemple R1 est le registre numéro 1).

• Les registres vont de R0 à R12.

Compléments pour les instructions DAT, INP et OUT :

• la pseudo-instruction DAT vous permet de mettre un nombre dans la mémoire en utilisant l'assembleur. Un label peut aussi être pris comme donnée.

• INP Rd,2 lis un nombre dans le registre d.

• OUT Rd,4 retourne en sortie le nombre du registre d.

• Pour OUT, vous pouvez retourner des nombres signés (paramètre 4), des nombres non signés (paramètre 5), des hexadécimaux (paramètre 6) ou des caractères (paramètre 7). Vous pouvez entrer des hexadécimaux comme 0xnnn partout où un nombre est attendu.

La liste d'instructions en anglais :

The AQA Instruction Set.

• LDR Rd, <memory ref> Load the value stored in the memory location specified by <memory ref> into register d.
• STR Rd, <memory ref> Store the value that is in register d into the memory location specified by <memory ref>.
• ADD Rd, Rn, <operand2> Add the value specified in <operand2> to the value in register n and store the reslit in register d.
• SUB Rd, Rn, <operand2> Subtract the value specified by <operand2> from the value in register n and store the reslit in register d.
• MOV Rd, <operand2> Copy the value specified by <operand2> into register d.
• CMP Rn, <operand2> Compare the value stored in register n with the value specified by <operand2>.
• B <label> Always branch to the instruction at position <label> in the program.
• B<condition> <label> Conditionally branch to the instruction at position <label> in the program if the last comparison met the criteria specified by the <condition>. Possible values for <condition> and their meaning are: EQ:Equal to, NE:Not equal to, GT:Greater than, LT:Less than.
• AND Rd, Rn, <operand2> Perform a bitwise logical AND operation between the value in register n and the value specified by <operand2> and store the reslit in register d.
• ORR Rd, Rn, <operand2> Perform a bitwise logical OR operation between the value in register n and the value specified by <operand2> and store the reslit in register d.
• EOR Rd, Rn, <operand2> Perform a bitwise logical exclusive or (XOR) operation between the value in register n and the value specified by <operand2> and store the result in register d.
• MVN Rd, <operand2> Perform a bitwise logical NOT operation on the value specified by <operand2> and store the result in register d.
• LSL Rd, Rn, <operand2> Logically shift left the value stored in register n by the number of bits specified by <operand2> and store the result in register d.
• LSR Rd, Rn, <operand2> Logically shift right the value stored in register n by the number of bits specified by <operand2> and store the result in register d.
• HALT Stop the execution of the program.

Bascule d'un programme en langage Python en un langage proche de l'assembleur

        
        INP R0, 2
        STR R0, x 
        LDR R0, x
        MOV R1, #2
        ADD R0, R0, R1
        STR R0,x
        HALT
        0
        0
        0
  x:    456
          

Le langage Python est un langage interpétré un peu hybride, c'est-à-dire que le code en Python est déjà compilé en un bytecode, un code intermédiaire qui n'est pas directement exécutable par un processeur mais qui est ensuite interprété par un interpréteur.

Pour comprendre comment un programme (simple) écrit dans le langage de haut-niveau Python va être traduit en langage machine, il est intéressant d'utiliser le module dis qui permet d'examiner le bytecode intermédiaire.

x = 4
x = x + 5            
                                    

import dis   # importation du module permettant l'étude
dis.dis('x = 4; x = x + 5; print(x)')
                                    

  1         0 LOAD_CONST               0 (4)
            2 STORE_NAME               0 (x)
            4 LOAD_NAME                0 (x)
            6 LOAD_CONST               1 (5)
            8 BINARY_ADD
           10 STORE_NAME               0 (x)
           12 LOAD_CONST               2 (None)
           14 RETURN_VALUE

        
            MOV R0, #4
            STR R0, x 
            LDR R0, x
            MOV R1, #5
            ADD R0, R0, R1
            STR R0,x
            HALT
            0
            0
            0
      x:    0
              

Prolongement : circuit et fonction booléenne

Un processeur est construit de circuits électroniques possédant des transistors jouant le rôle d'interrupteurs.

Si vous désirez comprendre comment il est possible de traduire les calculs logiques et binaires avec des circuits électroniques physiques, vous pouvez lire les pages 167 à 170 du livre en pdf cours se trouvant à cettte adresse ainsi téléchargeable à cette adresse sur le site de l'INRIA.

Exercices de renforcement

Pour accéder à une correction : sous forme d'une image

Correction de l'exercice : pdf téléchargeable ici.

Correction de l'exercice : pdf téléchargeable ici.

QCM

Propriétaire des ressources ci-dessous : ministère de l'Éducation nationale et de la jeunesse, licence CC BY SA NC

Voici une sélection de questions issues de la banque nationale de sujets, répondez à ces questions (attention, cette sélection n'est pas exhaustive).

Sitographie et bibliographie

• Manuel "INTERROS des LYCEES-Les VRAIS EXOS 1re donnés dans les lycées"-"numérique et sciences informatiques"-Stéphane PASQUET-Nathan

• Wikipédia pour l'UAL et l'architecture de Von Neumann

• Lien vers un excellent site (pixees, David Roche) : https://pixees.fr/informatiquelycee/n_site/nsi_prem_von_neu.html

• De nouveau, un lien vers pixees (Davis Roche) : https://pixees.fr/informatiquelycee/n_site/nsi_prem_sim_cpu.html

• Vers le site du YETI qui traite des commandes du simulateur : http://lesmathsduyeti.fr/lycee/nsi-1iere/language-assembleur/