Adloun

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. »

Définition 9.1Modèle d'architecture séquentielle

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.

Figure : L'architecture de von Neumann. Le trait décisif n'est pas la liste des organes : c'est que

la mémoire contient à la fois les données et le programme.</div>

ImportantL'idée décisive : le programme est une donnée

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 :

Figure : Le cycle d'exécution. Le compteur ordinal désigne l'instruction à charger ; tout le reste n'est qu'une manière de le faire avancer autrement que d'un cran.

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.

InstructionEffet
`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
Exemple 9.2Une addition, instruction par instruction

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 :

ÉtapeInstructionR1R2Mémoire
0(état initial)??, ,
1`CHARGE R1, 10`7?inchangée
2`CHARGE R2, 11`75inchangée
3`AJOUTE R1, R2`125inchangée
4`RANGE R1, 12`125
iRemarqueUne boucle en langage machine

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.

iRemarqueMono ou multiprocesseur

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. »

Définition 9.3Système d'exploitation

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.
iRemarque

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

CommandeEffet
`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
Attention

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
Figure : Les droits d'un fichier. La notation octale n'est pas une coquetterie d'informaticien :

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 :

NotationOctalSignification
`rw-r--r--``644`le propriétaire écrit, les autres lisent
`rwxr-xr-x``755`programme exécutable par tous
`rw-------``600`privé
iRemarque

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

Définition 9.4Paquet, encapsulation

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.

Figure : L'encapsulation. À l'arrivée, chaque couche retire l'en-tête qui la concerne et transmet

le reste à la couche au-dessus, sans jamais l'avoir interprété.</div>

ImportantTrois raisons, toutes pratiques
  • 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"
Figure : Le protocole du bit alterné. Un seul paquet est en vol à la fois : le récepteur n'a donc

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.

iRemarque

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émentRôle
Carte réseaurelie la machine au support, porte une adresse physique
Commutateurrelie les machines d'un même réseau local
Routeurrelie deux réseaux, choisit la route des paquets
Serveur DNStraduit un nom de domaine en adresse IP
Point d'accèsfait la même chose qu'un commutateur, sans fil
iRemarque

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é. »

Définition 9.5Capteur, actionneur

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
AttentionPourquoi la marge

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.

Continuer sur Adloun : animation, QCM, fiches, exercices