Machines, systèmes et réseaux
Cours complet · NSI (première), chapitre 9 · première, spécialité numérique et sciences informatiques
Travailler ce chapitre sur Adloun Exercices corrigés de ce chapitre
Les huit chapitres précédents ont écrit des programmes sans jamais demander qui les exécute. Il est temps de regarder la machine — son architecture, son système d'exploitation, et le réseau qui la relie aux autres. Le programme le formule ainsi : « exprimer un algorithme dans un langage de programmation a pour but de le rendre exécutable par une machine dans un contexte donné ».
9.1 L'architecture de von Neumann
Capacité attendue
« Distinguer les rôles et les caractéristiques des différents constituants d'une machine. »
Dans le modèle dit de von Neumann, une machine se compose de :
- une unité de commande, qui lit les instructions une à une et les fait exécuter ;
- une unité arithmétique et logique (UAL), qui effectue les calculs et les opérations booléennes ;
- une mémoire, qui contient à la fois les données et le programme ;
- des dispositifs d'entrée-sortie, qui relient la machine au monde ;
- des bus, qui transportent les informations entre ces éléments.
L'unité de commande et l'UAL forment le processeur.
la mémoire contient à la fois les données et le programme.</div>
Ce qui distingue ce modèle des machines à calculer antérieures n'est pas la liste des organes, c'est un point précis : le programme est rangé dans la même mémoire que les données. Une machine peut donc charger un programme différent sans être recâblée — et, en principe, produire ou modifier un programme comme n'importe quelle autre donnée.
C'est ce qui rend possibles le compilateur, le système d'exploitation, et l'ordinateur polyvalent que vous utilisez. Sans cela, chaque tâche demanderait une machine.
Repère historique : 1945 : le rapport et son nom
Le modèle porte le nom de John von Neumann, qui l'expose en 1945 dans un rapport préliminaire sur l'EDVAC. Le texte, diffusé sans être achevé, ne portait que sa signature — alors que les idées avaient été élaborées collectivement, notamment avec John Presper Eckert et John Mauchly, les concepteurs de l'ENIAC. La postérité a retenu un nom là où il en aurait fallu plusieurs ; c'est une chose qui arrive souvent en histoire des sciences, et qu'il n'est pas inutile de savoir.
Le programme situe l'époque : « les premiers ordinateurs ont été construits en 1948 et leur puissance a ensuite évolué exponentiellement ».
9.1.1 Dérouler une séquence d'instructions
Capacité attendue
« Dérouler l'exécution d'une séquence d'instructions simples du type langage machine. »
Dérouler un programme, pour un processeur, c'est répéter quatre gestes — toujours les mêmes :
Un processeur ne connaît ni les fonctions ni les boucles : il exécute des instructions élémentaires, chacune agissant sur des registres — de très petites mémoires internes — ou sur la mémoire principale. Voici un jeu d'instructions minimal, suffisant pour comprendre.
| Instruction | Effet |
|---|---|
| `CHARGE R, adr` | met dans le registre `R` le contenu de la case `adr` |
| `RANGE R, adr` | écrit le contenu de `R` dans la case `adr` |
| `AJOUTE R1, R2` | `R1` reçoit `R1 + R2` |
| `SOUSTRAIT R1, R2` | `R1` reçoit `R1 - R2` |
| `SAUTE etiq` | poursuit l'exécution à l'étiquette `etiq` |
| `SAUTESI R, etiq` | saute à `etiq` si `R` vaut |
Le programme suivant calcule la somme du contenu des cases et , et la range en .
CHARGE R1, 10
CHARGE R2, 11
AJOUTE R1, R2
RANGE R1, 12
Déroulement, en supposant que la case contient et la case contient :
| Étape | Instruction | R1 | R2 | Mémoire |
|---|---|---|---|---|
| 0 | (état initial) | ? | ? | , , |
| 1 | `CHARGE R1, 10` | 7 | ? | inchangée |
| 2 | `CHARGE R2, 11` | 7 | 5 | inchangée |
| 3 | `AJOUTE R1, R2` | 12 | 5 | inchangée |
| 4 | `RANGE R1, 12` | 12 | 5 |
Il n'existe pas d'instruction while. Une boucle se fabrique avec un saut conditionnel :
CHARGE R1, 20 ; compteur
CHARGE R2, 21 ; la valeur 1
boucle: SAUTESI R1, fin ; si le compteur vaut 0, on sort
SOUSTRAIT R1, R2 ; compteur = compteur - 1
SAUTE boucle
fin: RANGE R1, 22
Toutes les structures de contrôle du chapitre 3 se ramènent à ces sauts. C'est ce que fait un compilateur.
Hors programme
Le programme précise que « la présentation se limite aux concepts généraux » et que « des activités débranchées sont proposées » — c'est-à-dire menées sans machine, sur papier. Aucun jeu d'instructions réel n'est exigible : celui ci-dessus est une convention pédagogique, pas un standard.
9.1.2 Des circuits qui calculent
Le programme note que « les circuits combinatoires réalisent des fonctions booléennes ». C'est le lien direct avec le chapitre 2 : l'additionneur complet qui y a été écrit — somme , retenue — n'était pas un exercice abstrait. C'est la description d'un circuit réel, présent dans l'UAL de toute machine. Additionner deux entiers de 64 bits, c'est enchaîner 64 de ces circuits.
Le modèle décrit ci-dessus est séquentiel : une instruction après l'autre. Les machines actuelles comportent plusieurs cœurs, capables d'exécuter plusieurs séquences en parallèle. Cela ne change rien à ce chapitre — chaque cœur reste une machine de von Neumann — mais explique qu'un ordinateur puisse mener plusieurs tâches de front sans les alterner.
9.2 Le système d'exploitation
Capacité attendue
« Identifier les fonctions d'un système d'exploitation. Utiliser les commandes de base en ligne de commande. Gérer les droits et permissions d'accès aux fichiers. »
Le système d'exploitation est le programme qui gère les ressources de la machine et sert d'intermédiaire entre le matériel et les autres programmes. Ses fonctions principales :
- exécuter les programmes : les charger en mémoire, leur distribuer du temps de processeur, les arrêter ;
- gérer la mémoire : attribuer à chacun sa zone, et empêcher qu'il touche à celle des autres ;
- gérer les fichiers : organiser le stockage, contrôler les accès ;
- gérer les entrées-sorties : clavier, écran, réseau, capteurs ;
- gérer les utilisateurs : identités, droits, isolement.
Le programme demande explicitement que « les élèves utilisent un système d'exploitation libre », et que « les différences entre systèmes d'exploitation libres et propriétaires soient évoquées ». Les commandes ci-dessous sont celles des systèmes de la famille Unix — GNU/Linux, macOS.
9.2.1 La ligne de commande
| Commande | Effet |
|---|---|
| `pwd` | affiche le répertoire courant |
| `ls` | liste le contenu d'un répertoire |
| `ls -l` | le liste avec droits, propriétaire, taille, date |
| `cd rep` | change de répertoire |
| `mkdir rep` | crée un répertoire |
| `cp a b` | copie |
| `mv a b` | déplace ou renomme |
| `rm f` | supprime |
| `cat f` | affiche le contenu d'un fichier |
| `chmod mode f` | modifie les droits |
rm ne met rien à la corbeille : la suppression est immédiate et définitive. C'est la première leçon de la ligne de commande, et beaucoup l'ont apprise à leurs dépens.
9.2.2 Droits et permissions
Sur un système Unix, chaque fichier porte trois groupes de trois droits : pour son propriétaire, pour son groupe, et pour les autres. Les trois droits sont lecture (r), écriture (w) et exécution (x).
$ ls -l notes.csv
-rw-r--r-- 1 nour eleves 1240 7 aou 14:32 notes.csv
|+-++-++-+
| | | +--- les autres : lecture seule
| | +------ le groupe : lecture seule
| +--------- le proprietaire : lecture et ecriture
+----------- type : - pour un fichier, d pour un repertoire
c'est la seule base où un chiffre code exactement un groupe de droits.</div>
Les droits se notent aussi en base huit, chaque chiffre codant trois bits — lecture , écriture , exécution :
| Notation | Octal | Signification |
|---|---|---|
| `rw-r--r--` | `644` | le propriétaire écrit, les autres lisent |
| `rwxr-xr-x` | `755` | programme exécutable par tous |
| `rw-------` | `600` | privé |
C'est l'écriture en base huit du chapitre 1, employée pour ce qu'elle sait faire : un chiffre octal vaut exactement trois bits, et il y a exactement trois droits par groupe. La coïncidence n'en est pas une — c'est pour cela qu'on a choisi l'octal ici, comme on avait choisi l'hexadécimal pour les octets.
Hors programme
« Il ne s'agit pas d'une étude théorique des systèmes d'exploitation. » Ni ordonnancement, ni mémoire virtuelle, ni appels système : on identifie les fonctions, on se sert du système.
9.3 Les réseaux
Capacité attendue
« Mettre en évidence l'intérêt du découpage des données en paquets et de leur encapsulation. Dérouler le fonctionnement d'un protocole simple de récupération de perte de paquets (bit alterné). Simuler ou mettre en œuvre un réseau. »
9.3.1 Pourquoi découper en paquets
Un message transmis sur un réseau est découpé en paquets de taille limitée. Chaque paquet voyage indépendamment, muni d'en-têtes qui indiquent son destinataire, son expéditeur et son numéro d'ordre. L'ajout de ces en-têtes successifs, une couche après l'autre, s'appelle l'encapsulation.
le reste à la couche au-dessus, sans jamais l'avoir interprété.</div>
- Le partage. Si un fichier de 4 Go voyageait d'un bloc, il monopoliserait la ligne pendant toute sa durée. Découpé, il s'entrelace avec les autres communications.
- La reprise sur erreur. Un paquet perdu se retransmet seul ; sans découpage, la moindre erreur imposerait de tout recommencer.
- Le routage. Chaque paquet peut emprunter un chemin différent selon l'état du réseau, et contourner une liaison coupée.
9.3.2 Le protocole du bit alterné
Comment garantir qu'un message est bien arrivé, sur un canal qui peut perdre des paquets ? Le programme cite le plus simple des protocoles.
Emetteur Recepteur
-------- ---------
envoie paquet numerote 0 ---------> recoit 0, le garde
attend l'accuse de reception <--------- renvoie "recu 0"
envoie paquet numerote 1 ---------> recoit 1, le garde
attend <--------- renvoie "recu 1"
envoie paquet numerote 0 ---X PERDU
attend... rien ne vient
delai ecoule : renvoie le 0 ---------> recoit 0, le garde
<--------- renvoie "recu 0"
qu'à distinguer « celui que j'attends » de « celui que je viens de recevoir » — un bit suffit.</div>
Méthode : Pourquoi un seul bit suffit
Le numéro alterne entre et — d'où le nom. Cela suffit parce que l'émetteur n'envoie jamais le paquet suivant avant d'avoir reçu l'accusé du précédent : à tout instant, il n'y a qu'un paquet en vol, et le récepteur n'a qu'à distinguer « celui que j'attends » de « celui que je viens de recevoir ».
Le bit résout le cas piégeux : si c'est l'accusé qui se perd, l'émetteur renvoie le paquet ; le récepteur voit alors un numéro qu'il a déjà traité, comprend que c'est un doublon, le jette — et renvoie l'accusé. Sans le numéro, il enregistrerait deux fois la même donnée.
Le programme suggère d'expliquer et de simuler ce protocole « en mode débranché » : deux élèves, des papiers numérotés, et un troisième qui joue le canal en faisant disparaître un message de temps à autre. C'est l'activité qui fait comprendre le mécanisme le plus vite.
9.3.3 Un réseau, ses constituants
| Élément | Rôle |
|---|---|
| Carte réseau | relie la machine au support, porte une adresse physique |
| Commutateur | relie les machines d'un même réseau local |
| Routeur | relie deux réseaux, choisit la route des paquets |
| Serveur DNS | traduit un nom de domaine en adresse IP |
| Point d'accès | fait la même chose qu'un commutateur, sans fil |
Le programme demande que « le rôle des différents constituants du réseau local de l'établissement soit présenté » : le meilleur support est le réseau du lycée lui-même — combien de commutateurs, où est le routeur, par où sort-on vers l'extérieur, qui attribue les adresses.
9.4 Capteurs, actionneurs, interfaces
Capacité attendue
« Identifier le rôle des capteurs et actionneurs. Réaliser par programmation une IHM répondant à un cahier des charges donné. »
Un capteur convertit une grandeur physique — température, lumière, pression, position — en une valeur numérique exploitable par un programme. Un actionneur fait l'inverse : il transforme une commande numérique en effet physique — moteur, vérin, chauffage, diode.
Entre les deux, un programme. C'est le schéma de tout système embarqué, du thermostat au robot :
capteur acquisition traitement commande actionneur
def reguler(temperature_mesuree, consigne, marge=0.5):
"""Commande d'un chauffage, en tout ou rien avec hystérésis.
Renvoie True s'il faut chauffer, False sinon.
La marge évite que le chauffage ne commute sans arrêt autour de la
consigne — un défaut classique des régulations naïves.
"""
if temperature_mesuree < consigne - marge:
return True
if temperature_mesuree > consigne + marge:
return False
return None # dans la zone morte : on ne change rien
Sans elle, un capteur qui oscille de quelques centièmes autour de la consigne ferait démarrer et arrêter le chauffage plusieurs fois par seconde. La marge — on parle d'hystérésis — impose un écart minimal entre l'allumage et l'extinction. C'est aussi, en creux, la leçon du chapitre 2 : on ne compare pas des mesures physiques par égalité.
Piste de projet : Un objet connecté, ou son simulateur
Réaliser un système complet capteur programme actionneur, avec une interface. Selon le matériel disponible : une carte programmable réelle, ou une simulation où le capteur est remplacé par un curseur à l'écran et l'actionneur par un voyant.
Le cahier des charges doit être écrit avant : ce que le système mesure, ce qu'il commande, selon quelle règle, et comment on vérifie qu'il obéit. C'est la démarche du chapitre 3 — spécifier, puis tester — appliquée à un système physique.