Cours

Architecture des ordinateurs et systèmes d'exploitation

Programme (BO)	Modèle d’architecture de von Neumann : unité de traitement (UAL, registres), unité de commande, mémoire, dispositifs d’entrée-sortie. Dérouler l’exécution d’une séquence d’instructions simples de type langage machine. Le transistor, brique de base ; quelques ordres de grandeur. Systèmes d’exploitation : rôles et fonctions ; utiliser les commandes de base en ligne de commande ; gérer les droits et permissions d’accès aux fichiers. Périphériques d’entrée-sortie : identifier le rôle des capteurs et des actionneurs.
Prérequis	le binaire et le codage de l’information (chapitre Le binaire et l’écriture des nombres) ; savoir ce qu’est un programme et une variable. (→ fiches de révision : ch. 2)
Objectifs	comprendre comment une machine exécute un programme ; nommer les composants d’un ordinateur et leur rôle ; dérouler un petit programme en langage machine ; savoir ce que fait un système d’exploitation ; se déplacer et manipuler des fichiers en ligne de commande sous Linux ; lire et modifier les droits d’un fichier.

Situation de départ

1. Où se trouve un programme pendant qu’il s’exécute, et qui lit ses instructions une à une ?

2. Comment plusieurs applications ouvertes en même temps se partagent-elles un seul ordinateur sans se gêner ?

3. Sur un ordinateur partagé, qu’est-ce qui empêche un autre utilisateur de lire vos fichiers ?

Remarque — Le fil conducteur : un mille-feuille de couches

Un ordinateur qui affiche cette page fait, à la base, circuler des électrons dans des interrupteurs microscopiques. Comment passe-t-on de l’électron au clic de souris ? Grâce à un empilement de couches d’abstraction : chaque couche ne parle qu’à celle juste en dessous, et cache sa complexité à celle du dessus.

Ce chapitre gravit ce mille-feuille : on part de la brique du bas (le transistor), on monte au matériel (von Neumann) puis au langage machine, et on termine par la couche qui donne le plus de confort : le système d’exploitation. Les points qui dépassent le programme portent le badge au-delà du programme.

La brique de base : le transistor

Tout, dans un ordinateur, se ramène à deux états : le courant passe ou ne passe pas, qu’on note 1 et 0. L’objet qui réalise physiquement ce choix est le transistor.

Définition 1 — Le transistor

Un transistor est un minuscule interrupteur commandé électriquement : une troisième borne (la « commande ») décide si le courant passe ou non entre les deux autres. C’est un interrupteur sans pièce mécanique, qui bascule des milliards de fois par seconde.

En combinant quelques transistors, on fabrique des portes logiques qui calculent sur les 0 et les 1. Rappel du chapitre Le binaire et l’écriture des nombres : les portes ET, OU, NON (et le OU exclusif) réalisent les opérateurs booléens du même nom, décrits par leurs tables de vérité, et une porte OU exclusif associée à une porte ET forme déjà un demi-additionneur, qui additionne deux bits. En combinant ainsi des portes, on fabrique des circuits qui additionnent, comparent, mémorisent… et de proche en proche, tout un processeur. Le transistor est donc la brique élémentaire à partir de laquelle tout est construit.

À retenir — Quelques ordres de grandeur

Il faut avoir en tête des ordres de grandeur, pas des chiffres exacts :

• un transistor mesure aujourd’hui de quelques nanomètres à quelques dizaines de nanomètres (1 nm \(=10^{-9}\) m, soit environ 5 atomes de silicium côte à côte) ; les « 3 nm » annoncés par les fabricants sont un nom commercial plus qu’une vraie mesure ;

• un processeur de smartphone ou d’ordinateur contient des milliards à des dizaines de milliards de transistors (\(10^{9}\) à \(10^{10}\)) ;

• il exécute quelques milliards d’opérations par seconde : sa fréquence est de l’ordre du gigahertz (1 GHz \(=10^{9}\) battements par seconde).

Exemple — La loi de Moore

En 1965, Gordon Moore (cofondateur d’Intel) remarque que le nombre de transistors qu’on sait graver sur une puce double chaque année ; en 1975, il révise ce rythme : un doublement environ tous les deux ans. Cette observation, la loi de Moore, s’est vérifiée pendant un demi-siècle : de 2 300 transistors sur le premier microprocesseur (l’Intel 4004, en 1971) à plusieurs dizaines de milliards aujourd’hui. Ce n’est pas une loi physique mais une tendance, qui ralentit désormais : on approche de la taille de l’atome, en dessous de laquelle un interrupteur n’a plus de sens.

L’architecture de von Neumann

Comment organiser ces milliards d’interrupteurs pour exécuter un programme ? La réponse, proposée en 1945, est le modèle de von Neumann. Quasiment tous les ordinateurs, du smartphone au super-calculateur, le suivent encore.

Définition 2 — Les quatre unités du modèle de von Neumann

Une machine de von Neumann est faite de quatre grands organes :

• l’unité de commande : elle lit les instructions du programme, les décode et ordonne leur exécution (le « chef ») ;

• l’unité arithmétique et logique (UAL) : elle calcule (additions, comparaisons, ET/OU logiques…) ;

• la mémoire : elle range à la fois le programme et les données, dans des cases numérotées par une adresse ;

• les entrées-sorties (E/S) : elles font communiquer la machine avec le monde (clavier, écran, disque, réseau…).

L’unité de commande et l’UAL, réunies avec quelques cases de travail ultra-rapides, forment le processeur (ou CPU, Central Processing Unit).

Les organes sont reliés par des bus : des faisceaux de fils qui transportent les données, les adresses et les commandes.

Règle 1 — L’idée géniale : le programme est une donnée

Dans le modèle de von Neumann, le programme est rangé dans la même mémoire que les données, sous forme de nombres. Un ordinateur ne « connaît » donc pas ses programmes à l’avance : il en lit un depuis la mémoire, exactement comme il lirait un nombre. C’est ce qui rend une machine universelle : changer de programme, c’est juste changer les nombres en mémoire — pas recâbler la machine.

À retenir — La hiérarchie des mémoires

Toutes les mémoires ne se valent pas. Plus une mémoire est rapide, plus elle est petite et chère :

• les registres, dans le processeur : minuscules (quelques dizaines de cases) mais instantanés ;

• la mémoire vive (RAM) : quelques giga-octets, rapide, mais volatile (tout s’efface à l’extinction) ;

• le disque (SSD, disque dur) : énorme et permanent, mais bien plus lent.

Éteindre l’ordinateur sans enregistrer perd le travail resté en RAM : voilà pourquoi « enregistrer », c’est recopier de la RAM vers le disque.

Les entrées-sorties : capteurs et actionneurs (capacité attendue)

L’unité d’entrées-sorties est la porte par laquelle la machine échange avec le monde physique. On distingue deux rôles complémentaires.

Définition 3 — Capteur et actionneur

Un capteur mesure une grandeur du monde physique et la transforme en une valeur numérique entrant dans la machine (c’est une entrée). Un actionneur fait l’inverse : il reçoit un ordre numérique et agit sur le monde physique (c’est une sortie).

La chaîne capteur \(\to\) programme \(\to\) actionneur, au cœur de tout objet connecté.

Exemple — Un thermostat

Un radiateur connecté lit la température de la pièce (capteur), la compare à la consigne (programme), puis allume ou coupe le chauffage (actionneur). De même, un smartphone regorge de capteurs (écran tactile, accéléromètre, luminosité, GPS) et d’actionneurs (haut-parleur, vibreur, dalle de l’écran).

Remarque

Clavier, souris et écran sont les entrées-sorties les plus familières ; mais dès qu’un programme pilote un objet (robot, domotique, voiture), c’est toujours la même boucle : capter le monde, décider, agir. On y reviendra avec les objets connectés.

▶ Exercices d'application : exercices 1 à 6 (transistor, von Neumann, mémoires, capteurs/actionneurs)

Le processeur au travail : le langage machine

Le cycle d’exécution

Le processeur ne fait qu’une chose, mais des milliards de fois par seconde : répéter le cycle suivant.

À chaque tour, l’unité de commande utilise un registre spécial, le compteur de programme (ou compteur ordinal), qui contient l’adresse de la prochaine instruction. Normalement il avance d’un cran à chaque cycle ; une instruction de saut peut le forcer à une autre adresse — c’est ainsi qu’on réalise les tests et les boucles.

Langage machine et assembleur

Définition 4 — Langage machine, assembleur

Le processeur n’obéit qu’à un jeu réduit d’instructions très simples (charger une case, additionner, comparer, sauter…), codées en binaire : c’est le langage machine. Illisible pour un humain, on l’écrit avec des abréviations : c’est l’assembleur. Une instruction assembleur \(=\) une instruction machine, juste plus lisible.

Remarque — La grande pyramide des langages

Notre a = b + c en Python ne « tourne » pas tel quel : un autre programme le traduit en une suite d’instructions machine. Plus on descend, plus c’est proche de la machine et loin de l’humain : $\(\text{Python (très lisible)}\ \longrightarrow\ \text{assembleur}\ \longrightarrow\ \text{langage machine (des 0 et des 1)}.\)$ C’est encore le mille-feuille : chaque niveau cache la complexité du niveau du dessous.

Une machine-modèle : le Little Man Computer

Pour dérouler un vrai programme machine sans se noyer, on utilise une machine-modèle classique, le Little Man Computer (LMC). Elle est von Neumann en miniature :

• une mémoire de 100 cases numérotées de 00 à 99 (qui contiennent indistinctement programme et données) ;

• un seul registre de calcul, l’accumulateur (noté ACC) ;

• un compteur de programme qui pointe la prochaine instruction.

Instr.	Effet	En français
INP	lit une entrée dans ACC	« demande un nombre »
OUT	affiche ACC	« affiche le résultat »
LDA n	ACC \(\leftarrow\) contenu de la case n	« charge » (LoaD)
STA n	case n \(\leftarrow\) ACC	« range » (STore)
ADD n	ACC \(\leftarrow\) ACC \(+\) contenu de la case n	« ajoute »
SUB n	ACC \(\leftarrow\) ACC \(-\) contenu de la case n	« soustrais »
BRA n	saute à l’instruction en case n	saut toujours
BRZ n	saute à n si ACC \(=0\)	saut si zéro
BRP n	saute à n si ACC \(\geq 0\)	saut si positif
HLT	arrête la machine	stop
DAT	réserve une case pour une donnée	déclare une variable

Exemple — Dérouler un programme (capacité attendue)

Voici un programme LMC qui lit deux nombres et affiche leur somme. À gauche l’adresse de la case, à droite l’instruction qui y est rangée. a et b sont des étiquettes désignant les cases de données 08 et 09.

00   INP        « lire le 1er nombre »
01   STA a      « le ranger dans a »
02   INP        « lire le 2e nombre »
03   STA b      « le ranger dans b »
04   LDA a      « ACC <- a »
05   ADD b      « ACC <- a + b »
06   OUT        « afficher »
07   HLT
08   a  DAT
09   b  DAT

Déroulé pour les entrées 5 puis 3 (on suit l’accumulateur et les cases) :

Adr.	Instr.	ACC	a	b
00	INP	5	–	–
01	STA a	5	5	–
02	INP	3	5	–
03	STA b	3	5	3
04	LDA a	5	5	3
05	ADD b	8	5	3
06	OUT	8	5	3

La sortie est 8. Dérouler, c’est exactement cela : suivre ligne à ligne l’état de l’accumulateur et des cases.

Remarque — Deux compléments d’écriture

un DAT 1 réserve une case nommée un et y range d’avance la valeur 1 (sans valeur, la case vaut 0). Une étiquette (comme a et b ci-dessus) peut aussi être placée devant une instruction : BRA boucle saute alors à l’instruction marquée boucle, sans avoir à connaître son adresse.

Remarque — Sur machine

Des simulateurs en ligne, comme peterhigginson.co.uk/lmc/, exécutent ce processeur pas à pas dans le navigateur : on voit l’accumulateur, le compteur de programme et les cases changer. Écrire et tester ses propres programmes LMC (tests, boucles, multiplication…) est l’objet de la partie A du TP proposé en fin de chapitre.

▶ Exercices d'application : exercices 7 à 11 (le langage machine, le LMC)

Le système d’exploitation : le chef d’orchestre

Écrire chaque programme en langage machine, en gérant soi-même la mémoire, le disque et l’écran, serait un cauchemar. Une couche s’en charge à notre place : le système d’exploitation.

Définition 5 — Système d’exploitation (OS)

Un système d’exploitation (Operating System, OS) est l’ensemble de programmes qui gèrent le matériel et le mettent à disposition des applications et de l’utilisateur. Il joue les intermédiaires entre le matériel (compliqué, varié) et les logiciels (qui veulent juste « lire un fichier » ou « afficher une fenêtre »).

Règle 2 — Les grandes fonctions d’un OS

• gérer le processeur : décider quel programme s’exécute, et quand (plusieurs semblent tourner « en même temps ») ;

• gérer la mémoire : attribuer à chaque programme sa part de RAM, empêcher qu’ils s’écrasent l’un l’autre ;

• gérer les fichiers : organiser le disque en dossiers et fichiers ;

• gérer les périphériques : parler au clavier, à l’écran, à l’imprimante, au réseau, via des pilotes ;

• gérer les utilisateurs : comptes, mots de passe, droits d’accès.

Toujours le même mot-clé : abstraction. L’OS offre des actions simples (« ouvrir un fichier ») et cache la complexité du matériel dessous.

À retenir — Les grandes familles de systèmes d’exploitation

Trois lignées se partagent le monde : Windows (Microsoft), macOS (Apple) et surtout la famille UNIX/Linux. Cette dernière, invisible au grand public, est pourtant la plus répandue : elle fait tourner l’immense majorité des serveurs du Web, la plupart des smartphones (Android est bâti sur un noyau Linux) et les objets connectés. Windows et macOS sont des logiciels propriétaires (code source fermé) ; Linux est libre : chacun peut l’étudier, le modifier et le partager. Attention : « libre » ne veut pas dire « gratuit » — l’anglais free entretient la confusion.

▶ Exercices d'application : exercices 12 à 14 (le système d’exploitation)

Parler à l’OS en Linux : la ligne de commande

L’interface graphique (fenêtres, souris) est confortable, mais la ligne de commande (le terminal) reste indispensable : plus rapide, automatisable, et incontournable sur les serveurs (souvent sans écran). On travaille ici sous Linux : pour essayer les commandes, il suffit d’un terminal Linux en ligne, comme JSLinux (bellard.org/jslinux), déjà utilisé dans l’activité de découverte (on y est l’utilisateur root, de répertoire personnel /root).

À retenir — L’invite de commande

Le terminal affiche une invite qui rappelle qui vous êtes et où vous êtes, puis attend votre commande :

|eleve@pc-nsi|:|~/Documents|$ |ls|

Ici l’utilisateur est eleve, la machine pc-nsi, et le répertoire courant est ~/Documents. Le tilde ~ désigne votre répertoire personnel (/home/eleve).

↺ Retour sur l'activité. L’invite localhost:~# de l’activité « Perdu dans le terminal » se lisait de la même façon : la machine s’appelait localhost, et l’on se trouvait dans son répertoire personnel ~, c’est-à-dire /root, puisqu’on y était l’administrateur root.

L’arborescence des fichiers

Sous Linux, les fichiers sont organisés en arbre, dont la base est la racine, notée /.

/                          « la racine »
|-- home/
|   |-- eleve/             « votre repertoire personnel  (~) »
|       |-- Documents/
|       |   |-- cours.txt
|       |   |-- tp_os.txt
|       |-- Images/
|           |-- logo.png
|-- etc/
    |-- hosts

Définition 6 — Chemin absolu, chemin relatif

Un chemin désigne l’emplacement d’un fichier.

• un chemin absolu part de la racine et commence donc par / : /home/eleve/Documents/cours.txt ;

• un chemin relatif part du répertoire courant et ne commence pas par /.

Deux raccourcis universels : . désigne le répertoire courant, et .. le répertoire parent (un cran au-dessus).

↺ Retour sur l'activité. Depuis /root, l’activité faisait atteindre bin de deux façons : cd /bin suivait un chemin absolu, parti de la racine / ; cd ../bin un chemin relatif, qui remontait d’abord d’un cran avec ...

Exemple — Se repérer

Depuis /home/eleve/Documents, pour atteindre logo.png :

• chemin absolu : /home/eleve/Images/logo.png (trait plein : on part de la racine) ;

• chemin relatif : ../Images/logo.png (tirets : on remonte d’un cran avec .., puis on descend dans Images).

Les commandes de base (capacité attendue)

Commande	Rôle	Exemple
pwd	afficher le répertoire courant	pwd
ls	lister le contenu d’un répertoire	ls Documents
ls -l	lister en détail (droits, taille…)	ls -l
cd	changer de répertoire	cd ../Images
mkdir	créer un répertoire	mkdir Projets
touch	créer un fichier vide	touch note.txt
cat	afficher le contenu d’un fichier	cat cours.txt
cp	copier un fichier	cp a.txt sauve/
mv	déplacer ou renommer	mv a.txt b.txt
rm	supprimer un fichier	rm note.txt
rm -r	supprimer un répertoire et son contenu	rm -r Projets
man	afficher le manuel d’une commande	man ls

Ces commandes se combinent : par exemple, depuis ~/Documents, mkdir archives puis cp cours.txt archives/ rangent une copie de cours.txt dans un nouveau dossier archives. Les manipulations (construire une arborescence, copier, déplacer, supprimer, tester les droits avec deux utilisateurs) se font dans la partie B du TP proposé en fin de chapitre.

Remarque — Deux réflexes de survie

(1) rm ne pardonne pas : il supprime définitivement, sans corbeille. Un rm -r lancé au mauvais endroit peut effacer tout un dossier. On réfléchit avant de valider (option rm -i pour demander confirmation).
(2) Linux est sensible à la casse : Documents et documents sont deux répertoires différents. La touche Tab complète automatiquement les noms : on l’utilise sans modération, elle évite les fautes de frappe.

▶ Exercices d'application : exercices 15 à 19 et 27 (la ligne de commande Linux)

Droits et permissions

Linux est multi-utilisateur : plusieurs comptes partagent la machine, chacun avec ses fichiers. Il faut donc contrôler qui a le droit de faire quoi. Un compte particulier, l’administrateur (root), a tous les droits.

Règle 3 — Trois droits, trois catégories

Chaque fichier ou répertoire porte trois droits : $\(\texttt{r}=\text{lecture (\emph{read})},\quad \texttt{w}=\text{écriture (\emph{write})},\quad \texttt{x}=\text{exécution (\emph{execute})},\)$ accordés séparément à trois catégories d’utilisateurs : $\(\texttt{u}=\text{le propriétaire (\emph{user})},\quad \texttt{g}=\text{le groupe},\quad \texttt{o}=\text{les autres (\emph{others})}.\)$

Exemple — Lire une ligne de ls -l

|eleve@pc-nsi|:|~|$ |ls -l|
-rw-r--r--  1 eleve  eleve   58  8 sep 09:12 cours.txt
drwxr-xr-x  2 eleve  eleve 4096  8 sep 09:14 Projets

Décryptons la première chaîne -rw-r--r--, lue par groupes de trois après le premier caractère :

type	propriétaire (u)	groupe (g)	autres (o)
- (fichier)	rw-	r--	r--

Traduction : c’est un fichier ; le propriétaire peut le lire et écrire (rw-), le groupe et les autres peuvent seulement le lire (r--). Le d initial de la 2^e ligne indique un répertoire ; pour un dossier, x signifie « on peut le traverser ».

Règle 4 — Modifier les droits : chmod

La commande chmod change les permissions, avec la grammaire chmod [ugoa][+-=][rwx] fichier :

|chmod| o-r cours.txt     « retire aux autres le droit de lecture »
|chmod| g+w cours.txt     « donne au groupe le droit d'ecriture »
|chmod| u+x script.sh     « rend le fichier executable par son proprietaire »

(a \(=\) « tout le monde » \(=\) u, g et o à la fois ; = réinitialise.)

Règle 5 — Les droits en chiffres

Chaque droit est présent ou absent : c’est un bit. On donne à chaque droit une valeur, r\(\,=4\), w\(\,=2\), x\(\,=1\), et chaque catégorie s’écrit avec un chiffre, la somme de ses droits présents (de \(0\) à \(7\)). Trois chiffres, dans l’ordre propriétaire, groupe, autres, décrivent donc tous les droits d’un fichier ; chmod les accepte et fixe alors tous les droits d’un coup.

Exemple — chmod 754 fichier

	propriétaire (u)	groupe (g)	autres (o)
chiffre	\(7 = 4+2+1\)	\(5 = 4+1\)	\(4\)
en binaire	111	101	100
droits	rwx	r-x	r--

Après chmod 754 fichier, ls -l affiche -rwxr-xr--. On reconnaît l’écriture binaire du chapitre Le binaire et l’écriture des nombres : r, w, x sont les bits de poids \(4\), \(2\) et \(1\), donc un chiffre ne dépasse jamais \(\texttt{111}_2 = 7\). Codes courants : 755 (rwxr-xr-x, un script que tous peuvent lancer), 644 (rw-r--r--, un document lisible par tous), 700 (rwx------, privé).

Remarque — Pourquoi c’est un enjeu de sécurité

Les droits ne sont pas un détail d’administration : ils protègent vos données des autres comptes, et limitent les dégâts qu’un programme malveillant peut causer. Un fichier de mots de passe lisible par « les autres », c’est une fuite ; un fichier téléchargé rendu x sans réfléchir, c’est un risque. root, qui a tous les droits, est aussi le compte le plus dangereux : on ne l’utilise que lorsque c’est nécessaire.

▶ Exercices d'application : exercices 20 à 23 et 26 (droits et permissions)

Un peu d’histoire

Pour les curieux (facultatif) — De l’ampoule au smartphone : la grande accélération

1945 — Dans un rapport resté célèbre (le First Draft of a Report on the EDVAC), le mathématicien John von Neumann (1903–1957) décrit une machine où programme et données partagent la même mémoire. L’idée n’est pas de lui seul : elle doit beaucoup à Alan Turing (sa « machine universelle » de 1936) et aux ingénieurs Eckert et Mauchly, bâtisseurs de l’ENIAC. Mais c’est ce rapport qui diffuse le modèle — au point qu’il porte, un peu injustement, son seul nom.
1947 — Aux Bell Labs, Bardeen, Brattain et Shockley inventent le transistor (prix Nobel 1956). Fini les tubes à vide fragiles et brûlants des premiers ordinateurs — l’ENIAC (1945), premier grand calculateur électronique, en alignait près de \(18\,000\) dans une salle entière, pour \(30\) tonnes — : la brique moderne est née.

L’ENIAC et ses armoires de tubes à vide

1965 — Gordon Moore énonce sa loi. La miniaturisation s’emballe : l’Intel 4004 (1971) tient 2 300 transistors ; une puce actuelle en aligne des dizaines de milliards.
1969 — Aux Bell Labs encore, Ken Thompson et Dennis Ritchie créent UNIX, un système élégant et portable qui inspirera presque tous les suivants (et donnera naissance au langage C).
1991 — Un étudiant finlandais, Linus Torvalds, écrit « pour le plaisir » un noyau libre inspiré d’UNIX : Linux. Trois décennies plus tard, ce projet d’étudiant fait tourner le Web, Android et les super-calculateurs. Le mille-feuille de couches sur lequel vous lisez cette page a mis moins d’un siècle à se construire.

Pour les curieux (facultatif) — Margaret Hamilton et l’ordinateur d’Apollo 11

Dans les années 1960, au laboratoire d’instrumentation du MIT, l’Américaine Margaret Hamilton dirige l’équipe qui écrit le logiciel de vol des missions Apollo. L’ordinateur de bord, l’Apollo Guidance Computer, est minuscule à nos yeux : 2 048 mots de mémoire vive (16 bits chacun, soit 4 ko), 36 864 mots de mémoire morte, littéralement tissée à la main avec des fils passant ou non dans de petits anneaux magnétiques, et une horloge à 2 MHz, environ mille fois moins qu’un processeur actuel.
Le 20 juillet 1969, pendant la descente vers la Lune, l’écran affiche les alarmes 1202 puis 1201 : un radar inutile à cet instant envoie des données en continu, et le processeur a plus de travail qu’il ne peut en faire. Le logiciel avait été conçu pour résister à une telle surcharge : il partage le temps du processeur entre les tâches par ordre de priorité, abandonne les moins urgentes et garde le guidage du module lunaire. L’alunissage se poursuit. C’est exactement le premier rôle d’un système d’exploitation vu dans ce chapitre : gérer le processeur. En 2016, Margaret Hamilton reçoit la médaille présidentielle de la Liberté pour ce logiciel.
Sources : F. O’Brien, The Apollo Guidance Computer: Architecture and Operation, Springer, 2010 ; NASA, « Margaret Hamilton », nasa.gov.

Pour les curieux (facultatif) — Liens avec d’autres chapitres

• Ce qu’il réutilise. Les 0 et les 1 du chapitre Le binaire et l’écriture des nombres sont les états des transistors ; les sauts BRZ et BRP du Little Man Computer réalisent les if et les while des Bases de la programmation Python ; la traduction en langage machine distingue langages compilés et interprétés (Spécifier et mettre au point ses programmes).

• Ce qu’il prépare. Les serveurs du chapitre suivant, Le Web : réseaux et interactions homme-machine, seront le plus souvent des machines Linux, administrées en ligne de commande.

• En Terminale. Processus et systèmes d’exploitation détaillera le partage du processeur entre les programmes en cours, Systèmes sur puce réunira processeur, mémoire et entrées-sorties sur une seule puce.

Bilan — la carte mémoire

Notion	À retenir
Transistor	interrupteur commandé \(\to\) 0/1 ; brique de toutes les portes logiques
Ordres de grandeur	transistor \(\sim\) nm ; milliards par puce ; fréquence \(\sim\) GHz ; loi de Moore
von Neumann	unité de commande \(+\) UAL (\(=\) CPU) \(+\) mémoire \(+\) entrées-sorties
Idée clé	programme et données dans la même mémoire \(\to\) machine universelle
Mémoires	registres \(<\) RAM (volatile) \(<\) disque (permanent) : vitesse \(\downarrow\), taille \(\uparrow\)
Cycle CPU	chercher \(\to\) décoder \(\to\) exécuter, en boucle
Langage machine	instructions simples en binaire ; assembleur \(=\) version lisible
Dérouler	suivre l’accumulateur et les cases, instruction par instruction
Entrées-sorties	capteur \(=\) mesure (entrée) ; actionneur \(=\) agit (sortie) ; boucle capter/décider/agir
Système d’exploitation	gère processeur, mémoire, fichiers, périphériques, utilisateurs
Ligne de commande	pwd ls cd mkdir touch cat cp mv rm man ; . courant, .. parent
Chemins	absolu (commence par /) vs relatif (part du répertoire courant)
Droits	rwx pour u/g/o ; lire ls -l ; modifier avec chmod ; en chiffres r\(=4\), w\(=2\), x\(=1\) (754)

Retour à la situation de départ

1. Dans la mémoire, avec les données : c’est le modèle de von Neumann (§ II). L’unité de commande du processeur le lit instruction par instruction, en répétant le cycle chercher \(\to\) décoder \(\to\) exécuter (§ III).

2. C’est le travail du système d’exploitation : il décide quel programme utilise le processeur, et quand, et attribue à chacun sa part de mémoire sans qu’ils s’écrasent (§ IV).

3. Les droits d’accès : chaque fichier porte des droits r, w, x pour le propriétaire, le groupe et les autres ; chmod o-r retire aux autres le droit de lecture. Seul l’administrateur root garde tous les droits (§ VI).

Erreurs fréquentes

• Confondre mémoire vive et disque. La RAM est volatile : ce qui n’est pas enregistré sur le disque est perdu à l’extinction.

• Croire que le processeur « comprend » Python. Il n’exécute que du langage machine ; l’interpréteur Python traduit le programme, au fur et à mesure, en instructions machine.

• Oublier le / initial d’un chemin absolu, ou en mettre un à un chemin relatif.

• Se tromper de casse : Documents \(\neq\) documents sous Linux.

• Lancer rm -r sans réfléchir : suppression définitive, sans corbeille.

• Lire les droits d’un bloc : ils se lisent par groupes de trois (u, puis g, puis o).

Savoir-faire à maîtriser

À la fin du chapitre, je sais…

• nommer les composants du modèle de von Neumann et leur rôle ;

• distinguer un capteur (entrée : mesure) d’un actionneur (sortie : action) et citer des exemples ;

• citer des ordres de grandeur (taille, nombre de transistors, fréquence) et énoncer la loi de Moore ;

• dérouler une petite séquence d’instructions en langage machine (accumulateur et cases) ;

• expliquer ce qu’est un système d’exploitation et citer ses grandes fonctions ;

• me repérer dans une arborescence (chemins absolu et relatif, . et ..) ;

• utiliser les commandes de base en ligne de commande sous Linux ;

• lire une ligne de ls -l et modifier des droits avec chmod, en lettres (g+w) ou en chiffres (754).