Architecture des machines et systèmes d'exploitation

Un programme Python n'est qu'un texte : pour qu'il s'exécute, il faut une machine et un système d'exploitation. Ce chapitre ouvre le capot.

D'abord l'architecture de von Neumann, commune à tous les ordinateurs depuis $1945$, et la façon dont le processeur déroule des instructions machine très simples.

Puis les circuits combinatoires, briques électroniques qui réalisent les fonctions booléennes.

Enfin le système d'exploitation : ses fonctions, les commandes de base du terminal et la gestion des droits d'accès aux fichiers.

1. Le modèle de von Neumann

1.1 Les constituants

En $1945$, John von Neumann décrit l'architecture encore utilisée aujourd'hui.

Le processeur contient lui-même trois parties.

1.2 Le cycle d'exécution

Un processeur actuel effectue plusieurs milliards de cycles par seconde : c'est sa fréquence, exprimée en GHz.

1.3 Monoprocesseur et multiprocesseur

Une architecture monoprocesseur exécute une instruction à la fois.

Une architecture multiprocesseur (ou multicœur) réunit plusieurs processeurs qui partagent la mémoire et exécutent des programmes en parallèle.

Les processeurs des téléphones et des ordinateurs actuels ont de $4$ à $16$ cœurs. Les cartes graphiques en comptent des milliers, spécialisés dans les calculs répétitifs.

2. Le langage machine

2.1 Des instructions très simples

Le processeur ne comprend qu'un langage machine : des instructions codées en binaire, chacune très élémentaire. On les écrit lisiblement en assembleur.

Une ligne Python comme s = s + n devient plusieurs instructions machine : charger s et n dans des registres, additionner, ranger le résultat.

C'est le compilateur, ou l'interpréteur, qui fait la traduction.

2.2 Dérouler une séquence

Dérouler un programme, c'est suivre à chaque étape PC, les registres et la mémoire.

Exemple : calculer $n + (n - 1) + \cdots + 1$, avec $n$ dans la case $10$ et le résultat dans la case $11$.

0  LOAD R0, [10]       ; R0 = n
1  LOAD R1, [11]       ; R1 = 0
2  ADD R1, R1, R0      ; R1 = R1 + R0
3  SUB R0, R0, #1      ; R0 = R0 - 1
4  JNZ R0, 2           ; si R0 ≠ 0, retour en 2
5  STORE [11], R1
6  HALT

Pour $n = 3$ : après les deux chargements, R0 $= 3$ et R1 $= 0$.

Tour 1 : R1 $= 3$, R0 $= 2$, saut. Tour 2 : R1 $= 5$, R0 $= 1$, saut. Tour 3 : R1 $= 6$, R0 $= 0$, pas de saut. La case $11$ reçoit $6$.

Le bloc ci-dessous est un petit processeur simulé en Python. Il n'est pas nécessaire de lire la fonction executer en détail : change la valeur de la case $10$ dans memoire, ou modifie le programme, et observe le déroulement.

programme = [
    "LOAD R0, [10]",
    "LOAD R1, [11]",
    "ADD R1, R1, R0",
    "SUB R0, R0, #1",
    "JNZ R0, 2",
    "STORE [11], R1",
    "HALT",
]
memoire = {10: 3, 11: 0}

def valeur(x, reg):
    """#5 -> 5 (valeur immédiate), R0 -> contenu du registre R0."""
    if x[0] == "#":
        return int(x[1:])
    return reg[x]

def executer(programme, memoire):
    reg = {"R0": 0, "R1": 0, "R2": 0}
    pc = 0
    for cycle in range(200):                # garde-fou contre les boucles infinies
        instruction = programme[pc]         # 1. chercher
        nom, reste = instruction.split(" ", 1) if " " in instruction else (instruction, "")
        args = [a.strip() for a in reste.split(",")]   # 2. décoder
        pc = pc + 1
        if nom == "LOAD":                   # 3. exécuter
            reg[args[0]] = memoire[int(args[1][1:-1])]
        elif nom == "STORE":
            memoire[int(args[0][1:-1])] = reg[args[1]]
        elif nom == "ADD":
            reg[args[0]] = reg[args[1]] + valeur(args[2], reg)
        elif nom == "SUB":
            reg[args[0]] = reg[args[1]] - valeur(args[2], reg)
        elif nom == "JMP":
            pc = int(args[0])
        elif nom == "JNZ":
            if reg[args[0]] != 0:
                pc = int(args[1])
        elif nom == "HALT":
            print("HALT")
            return
        print(instruction.ljust(16), "PC =", pc, " R0 =", reg["R0"], " R1 =", reg["R1"])
    print("Arrêt forcé après 200 cycles : boucle infinie ?")

executer(programme, memoire)
print("mémoire :", memoire)

Essaie avec memoire = {10: 0, 11: 0} : que se passe-t-il, et pourquoi ? La réponse est dans l'exemple résolu, question b.

3. Les circuits combinatoires

Le processeur est construit avec des portes logiques : des circuits électroniques à transistors qui réalisent and, or, not (et aussi xor, nand) sur des tensions représentant $0$ et $1$.

Toute l'UAL est faite ainsi : calculer, c'est faire circuler des bits dans des portes.

def additionneur_complet(a, b, r):
    """Additionne les bits a et b et la retenue entrante r ; renvoie (somme, retenue)."""
    somme = (a != b) != r                       # a xor b xor r
    retenue = (a and b) or (r and (a != b))
    return int(somme), int(retenue)

print("a b r -> somme retenue")
for a in [0, 1]:
    for b in [0, 1]:
        for r in [0, 1]:
            print(a, b, r, "->", additionneur_complet(a, b, r))

Vérifie quelques lignes à la main : $1 + 1 + 1 = 3$, qui s'écrit $\overline{11}^{\,2}$, soit somme $1$ et retenue $1$.

4. Le système d'exploitation

4.1 Ses fonctions

4.2 Libre ou propriétaire

Les systèmes libres sont développés par des communautés et des entreprises. Ils font fonctionner la majorité des serveurs, des supercalculateurs et des téléphones.

Le choix engage le coût, la transparence, la possibilité de vérifier la sécurité, et la dépendance à un éditeur.

4.3 La ligne de commande

Le terminal permet de piloter le système par des commandes textuelles. Il est indispensable sur les serveurs, qui n'ont pas d'écran, et pour automatiser des tâches.

Voici une session typique. Lis-la ligne par ligne, en imaginant l'arborescence.

$ pwd
/home/ana
$ mkdir nsi
$ cd nsi
$ touch tp1.py
$ ls
tp1.py
$ cp tp1.py tp2.py
$ ls
tp1.py  tp2.py
$ cd ..
$ pwd
/home/ana

4.4 Droits et permissions

Chaque fichier a un propriétaire et un groupe. Le système distingue trois catégories d'utilisateurs, et trois droits.

La commande ls -l affiche par exemple :

-rwxr-xr--  1 ana eleves  1204 sept. 13 notes.txt

On modifie les droits avec chmod, de deux façons.

chmod g+w notes.txt     # ajoute l'écriture au groupe
chmod o-r notes.txt     # retire la lecture aux autres
chmod u+x script.py     # rend le fichier exécutable par sa propriétaire

chmod 754 notes.txt     # rwx r-x r--
chmod 644 notes.txt     # rw- r-- r--
chmod 700 notes.txt     # rwx --- ---

L'utilisateur root, l'administrateur, a tous les droits. On n'utilise ses pouvoirs (sudo) que pour administrer la machine.

def octal(droits):
    # à toi
    return 0

Et dans l'autre sens ? Ce bloc retrouve les neuf lettres à partir du nombre. Essaie $600$, $755$, $777$.

def lettres(octal):
    """754 -> 'rwxr-xr--'"""
    resultat = ""
    for chiffre in str(octal):
        c = int(chiffre)
        resultat = resultat + ("r" if c >= 4 else "-")
        resultat = resultat + ("w" if c % 4 >= 2 else "-")
        resultat = resultat + ("x" if c % 2 == 1 else "-")
    return resultat

print(lettres(754))

5. Exemple résolu pas à pas

À retenir