Les exercices à faire par écrit sont regroupés sur une fiche à imprimer, une par élève. Elle contient les schémas, les tableaux et les QCM à compléter, avec la place pour répondre : exercices 3, 6, 8, 9, 13, 19, 20, 22 et 23.
Tu utilises un ordinateur tous les jours, mais que se passe-t-il vraiment à l'intérieur lorsqu'il exécute un programme ?
Comment des composants qui ne connaissent que 0 et 1 parviennent-ils à additionner deux nombres ? Où sont rangées les instructions, où sont stockés les nombres calculés, et qui décide de l'ordre des opérations ? Et pourquoi presque toutes les machines, depuis 80 ans, suivent-elles le même plan d'organisation ?
Le composant de base d'un ordinateur est le transistor, inventé en 1947. C'est un interrupteur commandé par un signal électrique : il laisse passer le courant ou il le bloque. Un processeur actuel en contient plusieurs milliards, gravés sur une plaque de silicium de quelques centimètres carrés.
Dans un circuit, chaque fil est soit dans un état « bas », que l'on note 0, soit dans un état « haut », que l'on note 1. On retrouve les deux valeurs des booléens du chapitre 5.
En assemblant quelques transistors, on fabrique une porte logique : un petit circuit qui reçoit un ou deux bits en entrée et qui produit un bit en sortie. Chaque porte réalise une opération booléenne.
Chaque porte se dessine avec un symbole. Il en existe deux versions : tu peux rencontrer l'une ou l'autre. Les entrées sont à gauche, la sortie \(S\) est à droite.
Elle inverse son entrée : la sortie vaut 1 quand l'entrée vaut 0, et 0 quand l'entrée vaut 1. Le petit rond sur le symbole signifie « inversion ».
Sa sortie vaut 1 uniquement quand ses deux entrées valent 1.
Sa sortie vaut 1 dès qu'au moins une de ses entrées vaut 1.
Sa sortie vaut 1 quand exactement une de ses entrées vaut 1, c'est-à-dire quand ses deux entrées sont différentes.
À faire sur la fiche.
Complète la table de vérité de la porte NON.
| \(E\) | \(S\) |
|---|---|
| 0 | |
| 1 |
Complète les tables de vérité des trois portes à deux entrées.
| Porte ET | ||
|---|---|---|
| \(E_1\) | \(E_2\) | \(S\) |
| 0 | 0 | |
| 0 | 1 | |
| 1 | 0 | |
| 1 | 1 | |
| Porte OU | ||
|---|---|---|
| \(E_1\) | \(E_2\) | \(S\) |
| 0 | 0 | |
| 0 | 1 | |
| 1 | 0 | |
| 1 | 1 | |
| Porte OU exclusif | ||
|---|---|---|
| \(E_1\) | \(E_2\) | \(S\) |
| 0 | 0 | |
| 0 | 1 | |
| 1 | 0 | |
| 1 | 1 | |
L'opérateur « ou exclusif » entre deux bits renvoie 0 si les deux bits sont égaux et 1 s'ils sont différents. Il est symbolisé par le caractère \( \oplus \).
Ainsi :
On représente ici une suite de bits par un tableau contenant des 0 et des 1.
Exemples :
a = [1, 0, 1, 0, 1, 1, 0, 1]
b = [0, 1, 1, 1, 0, 1, 0, 0]
c = [1, 1, 0, 1]
d = [0, 0, 1, 1]
Écris la fonction ou_exclusif qui prend en paramètres deux tableaux de même longueur et qui renvoie un tableau où l’élément situé à la position i est le résultat de \( tab1[i] \oplus tab2[i] \).
Avec les exemples ci-dessus, cette fonction doit donner :
>>> ou_exclusif(a, b)
[1, 1, 0, 1, 1, 0, 0, 1]
>>> ou_exclusif(c, d)
[1, 1, 1, 0]
On peut relier des portes entre elles : la sortie de l'une devient l'entrée d'une autre. On obtient un circuit combinatoire : ses sorties ne dépendent que de la valeur de ses entrées.
Un circuit combinatoire réalise donc une fonction booléenne, et on le décrit entièrement par sa table de vérité.
Deux règles de lecture d'un schéma :
Pour trouver la table de vérité d'un circuit, on donne un nom à chaque fil intermédiaire et on avance de la gauche vers la droite, porte après porte.
À faire sur la fiche.
On considère le circuit suivant. Les fils intermédiaires sont nommés \(X\), \(Y\) et \(Z\).
Complète la table de vérité du circuit.
| \(A\) | \(B\) | \(X\) | \(Y\) | \(Z\) | \(S\) |
|---|---|---|---|---|---|
| 0 | 0 | ||||
| 0 | 1 | ||||
| 1 | 0 | ||||
| 1 | 1 |
Tu sais poser une addition en base 2 (chapitre 1). Avec deux bits seulement, il n'y a que quatre cas :
| Addition | Résultat en base 2 | Retenue | Chiffre des unités |
|---|---|---|---|
| 0 + 0 | 0 | 0 | 0 |
| 0 + 1 | 1 | 0 | 1 |
| 1 + 0 | 1 | 0 | 1 |
| 1 + 1 | 10 | 1 | 0 |
Le résultat tient sur deux bits : le chiffre des unités, noté \(S\) (comme « somme »), et la retenue, notée \(C\) (de l'anglais carry).
Ces deux colonnes sont des tables de vérité que tu connais déjà. Une machine peut donc additionner deux bits avec seulement deux portes logiques.
À faire sur la fiche.
Le circuit ci-dessous s'appelle un demi-additionneur.
À faire sur la fiche.
On considère le schéma suivant :
Compléter la table de vérité suivante :
| \(E_1\) | \(E_2\) | \(C_{\text{in}}\) | \(C_{\text{out}}\) | \(S\) |
|---|---|---|---|---|
| 0 | 0 | 0 | 0 | 0 |
| 0 | 0 | 1 | 0 | 1 |
| 0 | 1 | 0 | ||
| 0 | 1 | 1 | ||
| 1 | 0 | 0 | ||
| 1 | 0 | 1 | ||
| 1 | 1 | 0 | ||
| 1 | 1 | 1 |
Les premiers calculateurs électroniques se programmaient en déplaçant des câbles et des interrupteurs : changer de programme prenait des jours.
En 1945, le mathématicien John von Neumann décrit, pour la machine EDVAC, une organisation qui porte aujourd'hui son nom. Son idée centrale : le programme est enregistré dans la mémoire, comme les données. Pour changer de programme, il suffit alors de changer le contenu de la mémoire.
Dans ce modèle, une machine comporte quatre parties :
L'unité de commande et l'unité arithmétique et logique forment ensemble le processeur.
On parle d'architecture séquentielle : les instructions sont exécutées une par une, dans l'ordre.
Les ordinateurs, les téléphones et les consoles actuels suivent toujours ce modèle. On y retrouve :
| Constituant | Rôle | Caractéristiques |
|---|---|---|
| Processeur (CPU) | Exécute les instructions des programmes. | Fréquence d'horloge en gigahertz (GHz), nombre de cœurs. |
| Mémoire vive (RAM) | Contient les programmes en cours d'exécution et leurs données. | Très rapide, mais volatile : son contenu disparaît quand on coupe l'alimentation. Quelques gigaoctets (Go). |
| Mémoire de masse (SSD, disque dur, clé USB) | Conserve les fichiers et les programmes quand la machine est éteinte. | Plus lente que la mémoire vive, mais persistante. Plusieurs centaines de Go. |
| Périphériques d'entrée | Envoient des informations à la machine. | Clavier, souris, micro, webcam, capteurs… |
| Périphériques de sortie | Reçoivent des informations de la machine. | Écran, haut-parleurs, imprimante… |
Tous ces constituants sont reliés par des bus : des ensembles de fils sur lesquels circulent les bits.
La mémoire vive est une suite de cases numérotées. Le numéro d'une case est son adresse. Le processeur peut lire ou modifier directement n'importe quelle case à partir de son adresse.
Quand tu lances un programme, il est d'abord copié de la mémoire de masse vers la mémoire vive : c'est là que le processeur vient chercher ses instructions.
Une machine monoprocesseur possède un seul processeur : elle n'exécute qu'une instruction à la fois.
Pendant longtemps, on a rendu les machines plus puissantes en augmentant la fréquence de l'horloge. Mais un processeur qui va plus vite chauffe davantage, et cette piste a atteint ses limites vers 2005.
Les constructeurs placent donc aujourd'hui plusieurs processeurs dans la même machine : on parle d'architecture multiprocesseur. Le plus souvent, ils sont gravés sur la même puce et on les appelle des cœurs. Un ordinateur à 8 cœurs peut exécuter 8 instructions au même moment, par exemple celles de 8 programmes différents.
Chaque cœur, lui, fonctionne toujours selon le modèle de von Neumann.
À faire sur la fiche.
Entoure la bonne réponse sur ta fiche, puis vérifie ton score ici.
Voici un extrait de la fiche technique d'un ordinateur portable.
| Élément | Description |
|---|---|
| Processeur | 8 cœurs, 3,2 GHz |
| Mémoire vive | 16 Go |
| Stockage | SSD 512 Go |
| Écran | 15,6 pouces, tactile |
| Autres | Clavier, pavé tactile, webcam, micro, haut-parleurs, carte Wi-Fi |
Un processeur ne comprend ni Python ni aucun autre langage de programmation. Il ne sait exécuter que quelques opérations très simples : copier une valeur, additionner, soustraire, comparer… Chacune est une instruction machine, écrite en binaire. L'ensemble de ces instructions forme le langage machine du processeur.
Une instruction machine comporte deux parties :
Lire du binaire est pénible. On donne donc à chaque code un nom court : au lieu de 0011 0111, on écrit ADD 7. Cette écriture s'appelle le langage d'assemblage (ou assembleur). Elle correspond mot pour mot au langage machine.
Un programme écrit en Python doit être traduit en instructions machine pour être exécuté. Une seule ligne de Python correspond en général à plusieurs instructions machine.
Un vrai processeur possède des centaines d'instructions. Pour comprendre le principe, nous allons utiliser une machine imaginaire très simple.
Sa mémoire comporte 16 cases, d'adresses 0 à 15. Chaque case contient un octet.
Son processeur possède trois registres, c'est-à-dire trois petites mémoires internes très rapides :
Une instruction occupe une case : les 4 bits de gauche donnent le code de l'opération, les 4 bits de droite donnent une adresse.
| Code | Assembleur | Effet |
|---|---|---|
0001 | LOAD a | Copie dans ACC le contenu de la case d'adresse a. |
0010 | STORE a | Copie le contenu de ACC dans la case d'adresse a. |
0011 | ADD a | Ajoute à ACC le contenu de la case d'adresse a. |
0100 | SUB a | Retranche de ACC le contenu de la case d'adresse a. |
0000 | HALT | Arrête le programme. |
Par exemple, 0001 0110 se lit LOAD 6, car \(0110_{(2)} = 6\).
Pour exécuter un programme, le processeur répète sans cesse les mêmes étapes :
Au démarrage, CO vaut 0 : le programme commence donc à la case 0.
La mémoire de la machine contient ceci (les cases non indiquées contiennent 0) :
| Adresse | Contenu | Lecture | Commentaire |
|---|---|---|---|
| 0 | 0001 0110 | LOAD 6 | Copie dans ACC le contenu de la case 6. |
| 1 | 0011 0111 | ADD 7 | Ajoute à ACC le contenu de la case 7. |
| 2 | 0010 1000 | STORE 8 | Range le contenu de ACC dans la case 8. |
| 3 | 0000 0000 | HALT | Arrête le programme. |
| 6 | 0000 1100 | 12 | Contient la valeur 12, le premier nombre. |
| 7 | 0001 1110 | 30 | Contient la valeur 30, le second nombre. |
| 8 | 0000 0000 | 0 | Recevra le résultat. |
On note l'état de la machine après chaque instruction :
| Instruction exécutée | ACC | Case 8 | CO |
|---|---|---|---|
| (au départ) | 0 | 0 | 0 |
LOAD 6 | 12 | 0 | 1 |
ADD 7 | 42 | 0 | 2 |
STORE 8 | 42 | 42 | 3 |
HALT | 42 | 42 | arrêt |
Ce programme additionne les contenus des cases 6 et 7 et range le résultat dans la case 8. En Python, on aurait écrit c = a + b : une seule ligne, mais trois instructions machine.
Ce simulateur reproduit la machine simplifiée. À gauche, tu écris le contenu de la mémoire : une ligne par case, la première ligne étant la case 0. Une ligne contient soit une instruction (LOAD 6), soit un nombre entre 0 et 255. Une ligne vide vaut 0.
Clique sur « Exécuter » et observe les trois étapes du cycle, ou avance à ton rythme avec « Pas à pas ».
Processeur
Mémoire
Choisis un programme, puis clique sur « Exécuter » ou sur « Pas à pas ».
À faire sur la fiche.
La mémoire de la machine contient ceci (les autres cases contiennent 0) :
| Adresse | Contenu |
|---|---|
| 0 | LOAD 8 |
| 1 | SUB 9 |
| 2 | ADD 10 |
| 3 | STORE 11 |
| 4 | HALT |
| 8 | 50 |
| 9 | 8 |
| 10 | 3 |
| 11 | 0 |
Complète ce tableau, sans utiliser le simulateur.
| Instruction exécutée | ACC | Case 11 | CO |
|---|---|---|---|
| (au départ) | 0 | 0 | 0 |
LOAD 8 | |||
SUB 9 | |||
ADD 10 | |||
STORE 11 | |||
HALT | arrêt |
Tu peux ensuite vérifier ta réponse avec le simulateur : choisis « Programme mystère » et avance pas à pas.
À faire sur la fiche.
Un élève a voulu additionner 20 et 37. Il a écrit ceci, en commençant à la case 0, mais il a oublié le HALT :
LOAD 3
ADD 4
STORE 5
20
37
0
STORE 5, le processeur ne s'arrête pas : il va chercher la case 3. Elle contient 20, qui s'écrit 0001 0100. Quelle instruction le processeur y lit-il ?Conclusion. Dans la mémoire, rien ne distingue une instruction d'une donnée : un octet est une instruction dès que le compteur ordinal arrive sur sa case. Sans HALT, le processeur continue et exécute les données comme si c'étaient des instructions.
Jusqu'ici, la machine exécute les instructions dans l'ordre des cases. Pour traduire un if ou un while de Python, il faut pouvoir changer cet ordre. C'est le rôle des instructions de saut, qui modifient le compteur ordinal.
| Code | Assembleur | Effet |
|---|---|---|
0101 | JMP a | Saut : la prochaine instruction exécutée sera celle de la case a (CO reçoit a). |
0110 | JZ a | Saut si zéro : si ACC vaut 0, CO reçoit a. Sinon, on passe simplement à l'instruction suivante. |
Avec JZ, la suite du programme dépend d'un test : c'est une instruction conditionnelle. Avec JMP vers une case déjà exécutée, on revient en arrière : c'est une boucle.
À faire sur la fiche.
La mémoire de la machine contient ceci :
| Adresse | Contenu |
|---|---|
| 0 | LOAD 6 |
| 1 | JZ 5 |
| 2 | SUB 7 |
| 3 | STORE 6 |
| 4 | JMP 1 |
| 5 | HALT |
| 6 | 3 |
| 7 | 1 |
Sur ta fiche, complète le tableau des instructions exécutées, dans l'ordre, jusqu'à l'arrêt du programme. Les trois premières lignes sont données.
| Adresse | Instruction exécutée | ACC | Case 6 |
|---|---|---|---|
| 0 | LOAD 6 | 3 | 3 |
| 1 | JZ 5 | 3 | 3 |
| 2 | SUB 7 | 2 | 3 |
| … | … | … | … |
SUB 7 est-elle exécutée ?La case 6 joue le rôle d'une variable n. Complète le programme Python équivalent :
n = 3
while ... :
n = ...
Tu peux ensuite vérifier ton tableau avec le simulateur (programme « Compte à rebours »).
À faire sur la fiche.
Entoure la bonne réponse sur ta fiche, puis vérifie ton score ici.
STORE 9 ?