Un système d'exploitation, appelé OS en anglais (Opérating System), permet de faire fonctionner un microprocesseur en aluant de la mémoire et en donnant l'accès aux différentes ressources disponibles (fichiers, périphériques, ...).

Les plus connus sont MS-DOS, android, Windows, Unix, Linux, OS X et macOS.

Vous avez déjà pu tester les commandes MS-DOS pour créer des répertoires et des fichiers, dans l'environnement Windows, qui est un logiciel payant, sous licence.

Linux est un système d'exploitation libre qui ne contient pas de code Unix, mais qui s'en inspire. Un système d'exploitation est souvent écrit en langage C.

Il existe de nombreuses distributions Linux, dont la plus connue est Ubuntu.

Raspberry Pi OS (appelé précédemment Raspbian) fonctionne avec Raspberry Pi.

Cliquer sur le lien suivant qui vous permettra de vous familiariser avec les commandes linux : https://luffah.xyz/bidules/Terminus/

Un programme écrit à l'aide d'un langage de haut de niveau (on parle de "code source") est, comme nous l'avons vu l'année dernière, transformé en langage machine afin de pouvoir être exécuté par un ordinateur.

On appelle processus un programme en cours d'exécution. Attention, il ne faut pas confondre le code source du programme et un processus, qui lui correspond à l'exécution de ce programme par un ordinateur. Pour prendre une image assez classique, si une recette de cuisine correspond au code source du programme, le cuisinier en train de préparer cette recette dans sa cuisine correspond à un processus.

Dans les années 1970 les ordinateurs personnels n'étaient pas capables d'exécuter plusieurs tâches à la fois : on lancait un programme et on y restait jusqu'à ce que celui-ci plante ou se termine.

Tous les systèmes d'exploitation "modernes" (Linux, Windows, macOS, Android, iOS...) sont capables de gérer l'exécution de plusieurs processus en même temps. Mais pour être précis, cela n'est pas en véritable "en même temps", mais plutôt un "chacun son tour". Pour gérer ce "chacun son tour", les systèmes d'exploitation attribuent des "états" au processus.

Voici les différents états :

• Lorsqu'un processus est en train de s'exécuter (qu'il utilise le microprocesseur), on dit que le processus est dans l'état "élu".

• Un processus qui se trouve dans l'état élu peut demander à accéder à une ressource pas forcément disponible instantanément (par exemple lire une donnée sur le disque dur). Le processus ne peut pas poursuivre son exécution tant qu'il n'a pas obtenu cette ressource. En attendant de recevoir cette ressource, il passe de l'état "élu" à l'état "bloqué"

• Lorsque le processus finit par obtenir la ressource attendue, celui-ci peut potentiellement reprendre son exécution. Mais comme nous l'avons vu ci-dessus, les systèmes d'exploitation permettent de gérer plusieurs processus "en même temps", mais un seul processus peut se trouver dans un état "élu" (le microprocesseur ne peut "s'occuper" que d'un seul processus à la fois). Quand un processus passe d'un état "élu" à un état "bloqué", un autre processus peut alors "prendre sa place" et passer dans l'état "élu". Le processus qui vient de recevoir la ressource attendue ne va donc pas forcément pouvoir reprendre son exécution tout de suite, car pendant qu'il était dans un état "bloqué" un autre processus a "pris sa place". Un processus qui quitte l'état bloqué ne repasse pas forcément à l'état "élu", il peut, en attendant que "la place se libère" passer dans l'état "prêt" (sous entendu "j'ai obtenu ce que j'attendais, je suis prêt à reprendre mon exécution dès que la "place sera libérée"").

Le passage de l'état "prêt" vers l'état "élu" constitue l'opération "d'élection". Le passage de l'état élu vers l'état bloqué est l'opération de "blocage". Un processus est toujours créé dans l'état "prêt". Pour se terminer, un processus doit obligatoirement se trouver dans l'état "élu".

On peut résumer tout cela avec le diagramme suivant :

Il est vraiment important de bien comprendre que le "chef d'orchestre" qui attribue aux processus leur état "élu", "bloqué" ou "prêt" est le système d'exploitation. On dit que le système gère l'ordonnancement des processus (tel processus sera prioritaire sur tel autre...)

Chose aussi à ne pas perdre de vu : un processus qui utilise une ressource R doit la "libérer" une fois qu'il a fini de l'utiliser afin de la rendre disponible pour les autres processus. Pour libérer une ressource, un processus doit obligatoirement être dans un état "élu".

Un processus peut créer un ou plusieurs processus à l'aide d'une commande système ("fork" sous les systèmes de type Unix). Imaginons un processus A qui crée un processus B. On dira que A est le père de B et que B est le fils de A. B peut, à son tour créé un processus C (B sera le père de C et C le fils de B). On peut modéliser ces relations père/fils par une structure arborescente (voir le cours si nécessaire).

Si un processus est créé à partir d'un autre processus, comment est créé le tout premier processus ?

Sous un système d'exploitation comme Linux, au moment du démarrage de l'ordinateur un tout premier processus (appelé processus 0 ou encore Swapper) est créé à partir de "rien" (il n'est le fils d'aucun processus). Ensuite, ce processus 0 crée un processus souvent appelé "init" ("init" est donc le fils du processus 0). À partir de "init", les processus nécessaires au bon fonctionnement du système sont créés (par exemple les processus "crond", "inetd", "getty",...). Puis d'autres processus sont créés à partir des fils de "init"...

On peut résumer tout cela avec le schéma suivant :

N. B. Tous ces noms de processus ne sont pas à retenir, ils sont juste donnés pour l'exemple. Il est juste nécessaire d'avoir compris les notions de processus père et processus fils et la structure arborescente.

Chaque processus possède un identifiant appelé PID (Process Identification), ce PID est un nombre. Le premier processus créé au démarrage du système à pour PID 0, le second 1, le troisième 2... Le système d'exploitation utilise un compteur qui est incrémenté de 1 à chaque création de processus, le système utilise ce compteur pour attribuer les PID aux processus.

Chaque processus possède aussi un PPID (Parent Process Identification). Ce PPID permet de connaitre le processus parent d'un processus (par exemple le processus "init" vu ci-dessus à un PID de 1 et un PPID de 0). À noter que le processus 0 ne possède pas de PPID (c'est le seul dans cette situation).

5.1 - La commande ps :

Sous Linux il existe des commandes permettant de visualiser les processus :

• la commande ps utilisée avec les options :
  • l : (ps -l) permet un affichage avec des attributs long
  • u : (ps -u) permet de préciser l'utilisateur
  • aef (ps -aef) permet de visualiser les processus en cours un ordinateur, notamment les PID et les PPID de ces processus. Problème : La commande ps ne permet pas de suivre en temps réel les processus (affichage figé).

Branchez et mettre sous tension votre Raspberry pi

Exécutez "LXTerminal"

Entrez la ligne de commande ps -l

Vous devez obtenir un affichage ressemblant à l'image suivante :

• La colonne S indique l’état (state) du processus : S pour stopped, R pour running et Z pour zombie.
• PID est le processus identifier : un identifiant sous forme d’entier donné par le système.
• PPID est le parent processus identifier qui donne l’identifiant du parent qui a engendré le processus. CMD est le nom de la commande.
• TTY (tty ou pts/n°) : terminal associé au processus.

Ouvrir deux autres fenêtres LXTerminal et exécuter la commande ps -l dans celles-ci

Que remarquez-vous ?

Dans l'une des 3 fenêtres du terminal, exécuter la commande ps -u

La commande pstree permet d'afficher les processus sous la forme d'un arbre

a) Quel nom prend le processus "init" dans ce système d'exploitation ?

b) Listez les enfants de "init" qui mènent au processus pstree

c) Quel est le parent de pstree ?

Exécutez la commande ps -aef

d) Retouvez les USER, UID, PID, PPID et CMD des 4 ancêtres de l'une des commandes bash

e) Qui est l'utilisateur "root" ?

f) Quel est sa particularité ?

5.2 - La commande top :

la commande top permet d'avoir un suivi en temps réel des processus.

Câblez une LED sur le port GPIO 18 du SoC Raspberry pi

La LED est considérée comme une sortie pour le SoC. Un capteur serait considéré comme une entrée

Exécuter l'application de programmation Thonny Python IDE

Recopier le code suivant dans l'application Thonny Python, puis exécuter ce code :

Ajoutez des commentaires aux lignes 3, 5, 6 et 7

Dans un terminal lancez la commande top -d 0.5, puis exécuter le programme ci-dessus

Ouvrir une nouvelle fenêtre LXTerminal, exécutez python et tapez le code suivant :

>>> while True:
...    print("Bonjour tout le monde")
...Entrée

Quelle est le PID et %CPU de python ?

5.3 - La commande kill :

la commande kill permet de supprimer un processus. L'utilisation de cette commande est très simple, il suffit de taper kill suivi du PID du processus à supprimer (exemple : kill 4242 permet de supprimer le processus de PID 4242)

Tuez le processus qui utilise le plus de ressources processeur et recopiez la commande ci-dessous

Quelle est la commande qu'il faut écrire pour tuer le processus "init" ? que se passe-t-il si on l'exécute ?

Plusieurs processus peuvent être dans l’état prêt, comment choisir celui qui sera élu ? L’ordonnanceur (scheduler) classe les processus prêts dans une file et le répartiteur (dispatcher) alloue quant à lui un processeur à l’élu dans le cas d’une architecture multiprocesseur. Il existe plusieurs politiques d’ordonnancement dont le choix va dépendre des objectifs du système.

Exemples :

• Premier arrivé, premier servi : simple, mais peu adapté à la plupart des situations.
• Plus court d’abord : très efficace, mais il est la plupart du temps impossible de connaître à l’avance le temps d’exécution d’un processus.
• Priorité : le système alloue un niveau de priorité aux processus. Cependant des processus de faible priorité peuvent ne jamais être élus.
• Tourniquet : un quantum de temps est alloué à chaque processus. Si le processus n’est pas terminé au bout de ce temps, il est mis en bout de file en état prêt.
• Un système hybride entre tourniquet et priorité qu’on retrouve dans les systèmes Unix.

Pour terminer, nous allons maintenant étudier le phénomène d'interblocage (deadlock en anglais).

Soient 2 processus P1 et P2, soit 2 ressources R1 et R2. Initialement, les 2 ressources sont "libres" (utilisées par aucun processus).

Le processus P1 commence son exécution (état élu), il demande la ressource R1.

Il obtient satisfaction puisque R1 est libre, P1 est donc dans l'état "prêt". Pendant ce temps, le système a passé P2 à l'état élu : P2 commence son exécution et demande la ressource R2.

P2 obtient immédiatement R2 puisque cette ressource était libre. P2 repasse immédiatement à l'état élu et poursuit son exécution (P1 lui est toujours dans l'état prêt). P2 demande la ressource R1

il se retrouve dans un état bloqué puisque la ressource R1 a été attribuée à P1 : P1 est dans l'état prêt, il n'a pas eu l'occasion de libérer la ressource R1 puisqu'il n'a pas eu l'occasion d'utiliser R1 (pour utiliser R1, P1 doit être dans l'état élu).

P2 étant bloqué (en attente de R1), le système passe P1 dans l'état élu et avant de libérer R1, il demande à utiliser R2.

Problème : R2 n'a pas encore été libéré par P2, R2 n'est donc pas disponible, P1 se retrouve bloqué.

Résumons la situation à cet instant : P1 possède la ressource R1 et se trouve dans l'état bloqué (attente de R2), P2 possède la ressource R2 et se trouve dans l'état bloqué (attente de R1)

Pour que P1 puisse poursuivre son exécution, il faut que P2 libère la ressource R2, mais P2 ne peut pas poursuivre son exécution (et donc libérer R2) puisqu'il est bloqué dans l'attente de R1. Pour que P2 puisse poursuivre son exécution, il faut que P1 libère la ressource R1, mais P1 ne peut pas poursuivre son exécution (et donc libérer R1) puisqu'il est bloqué dans l'attente de R2. Bref, la situation est totalement bloquée !

Cette situation est qualifiée d'interblocage (deadlock en anglais).

En suivant les arcs, on se rend compte qu'il y a un cycle, qui démontre l'interblocage

Il existe plusieurs solutions permettant soit de mettre fin à un interblocage (cela passe par l'arrêt d'un des 2 processus fautifs) ou d'éviter les interblocage, mais ces solutions ne seront pas étudiées ici.

Depuis une fenêtre LXTerminal, créer un sous-dossier process dans /home/pi avec la commande mkdir. Rendez-vous dans ce dossier process avec la commande cd, puis tapez nano test.py et saisir le code python suivant :

import time,os
os.system('clear')
t=int(time.time())+1
while True:
		t+=1
		i=0
		while t>time.time():
			i**3
			i+=1
		print("\033[H\033[J",int((i/100)))ctrlx

Enregistrer le programme.

Exécuter la ligne de commande python test.py

Le programme affiche le nombre de fois qu'il aura pu incrémenter i durant 1 seconde. On remarque que ce nombre varie en fonction de l'ordonnancement des taches

Dans une nouvelle fenêtre LXTerminal, exécuter top -u pi i et noter le numéro de processus du processus python

Dans une nouvelle fenêtre LXTerminal, exécuter une nouvelle fois la commande python test.py depuis le bon dossier

Changer la priorité du 1er processus python en mettant un renice à +20 et le 2ème à -20. Attention pour réduire la priorité il faut faire précéder la commande renice par sudo

Que constatez-vous ? Rechercher le processus ancêtre qu'ils ont en commun, tuez cet ancêtre, quel est le résultat ?

Sept processus Pi sont dans la situation suivante par rapport aux ressources Ri:

• P1 a obtenu R1 et demande R2;
• P2 demande R3 et n’a obtenu aucune ressource
• P3 demande R2 et n’a obtenu aucune ressource
• P4 a obtenu R2 et demande R3
• P5 a obtenu R3 et demande R5
• P6 a obtenu R6 et demande R2
• P7 a obtenu R5 et demande R2.

On voudrait savoir s’il y a interblocage.

Construire un graphe orienté où les sommets sont les processus et les ressources, tels que :

• la présence de l’arc Ri → Pj signifie que le processus Pj a obtenu la ressource Ri;
• la présence de l’arc Pj → Ri signifie que le processus Pj demande la ressource Ri.

Complétez le graphe Processus.drawio avec drawio :

Il y a interblocage lorsque des cycles sont présents dans le graphe. Chercher ces cycles afin de déterminer s’il y a bien interblocage ou non. Tracez-les en rouge, avec drawio, si vous en trouvez

Réponse

Pour chacune des questions, une seule des quatre réponses est exacte.

1. Parmi les commandes suivantes, laquelle permet d’afficher les processus en cours d’exécution ? dir ps ls man

2. Quelle abréviation désigne l’identifiant d’un processus dans un système d’exploitation de type UNIX ? PIX SIG PID SID

3. Comment s’appelle la gestion du partage du processeur entre différents processus ? L’interblocage L’ordonnancement La planification La priorisation

4. Quelle commande permet d’interrompre un processus dans un système d’exploitation de type UNIX ? stop interrupt end kill

Un processeur choisit à chaque cycle d’exécution le processus qui doit être exécuté. Le tableau ci-dessous donne pour trois processus P1, P2, P3 :

• la durée d’exécution (en nombre de cycles),
• l’instant d’arrivée sur le processeur (exprimé en nombre de cycles à partir de 0),
• le numéro de priorité.

Le numéro de priorité est d’autant plus petit que la priorité est grande. On suppose qu’à chaque instant, c’est le processus qui a le plus petit numéro de priorité qui est exécuté, ce qui peut provoquer la suspension d’un autre processus, lequel reprendra lorsqu’il sera le plus prioritaire.

Reproduire le tableau ci-dessous sur la copie et indiquer dans chacune des cases le processus exécuté à chaque cycle.

On suppose maintenant que les trois processus précédents s’exécutent et utilisent une ou plusieurs ressources parmi R1, R2 et R3.

Parmi les scénarios suivants, lequel provoque un interblocage ? Justifier.