CHAPITRE : GESTION DES PROCESSUS

I - Introduction

Les années 1960 ont constitué un tournant pour les système d'exploitation. Dans le cadre du projet MAC au MIT (Massachusset Institute of Technology), le système d'exploitation CTTS est publié en 1961. C'est l'un des tout premiers système d'exploitation à temps partagé, permettant à plusieurs utilisateurs d'utiliser un ordinateur en même temps. C'est une déclinaison du multitâche apparu peu de temps avant, et c'est cette apparente simultaneité dans l'exécution des programmes qui a permis de se diriger vers l'informatique moderne.

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. Les systèmes d'exploitation récents (Windows, Linux ou osX par exemple) permettent d'exécuter plusieurs tâches simultanément - ou en tous cas, donner l'impression que celles-ci s'exécutent en même temps. A un instant donné, il n'y a donc pas un mais plusieurs programmes qui sont en cours d'exécution sur un ordinateur : on les nomme processus. Une des tâches du système d'exploitation est d'allouer à chacun des processus les ressources dont il a besoin en termes de mémoire, entrées-sorties ou temps processeur, et de s'assurer que les processus ne se gênent pas les uns les autres.

si l'on prend l'exemple du smartphone, cet ordinateur que l'on a dans la poche, alors que nous regardons une vidéo, il va suivre les antennes relais et se synchroniser avec, écouter s'il y a un appel téléphonique ou des SMS qui arrive, vérifier les nouveaux courriers électroniques, mettre à jour les notifications des différents réseaux sociaux,etc. Il y a toute une myriade de processus qui s'éxécute de façon «simultanée».

Nous avons tous été confrontés à la problématique de la gestion des processus dans un système d'exploitation, en tant qu'utilisateur :

• quand nous cliquons sur l'icône d'un programme, nous provoquons la naissance d'un ou plusieurs processus liés au programme que nous lançons
• quand un programme ne répond plus, il nous arrive de lancer le gestionnaire de taches pour tuer le processus en défaut

Nous allons voir en détails dans cette séquence comment les processus sont gérés dans le système d'exploitation Linux.

II - Qu'est-ce qu'un processus ?

• un ensemble d'instructions à exécuter - souvent stockées dans un fichier sur lequel on clique pour lancer un programme (par exemple firefox.exe)
• un espace mémoire dédié à ce processus pour lui permettre de travailler sur des données qui lui sont propres : si vous lancez deux instances de firefox, chacune travaillera indépendament de l'autre avec ses propres données.
• des ressources matérielles : processeur, entrées-sorties (accès à internet en utilisant la connexion Wifi).
• des ressources mémoires

Il ne faut donc pas confondre le fichier contenant un programme (portent souvent l'extension .exe sous windows) et le ou les processus qu'il engendre quand il est exécuté : Un programme est juste un fichier contenant une suite d'instructions (firefox.exe par exemple) alors que les processus sont des instances de ce programme ainsi que les ressources nécessaires à leur exécution (plusieurs fenêtres de firefox ouvertes en même temps).

Pour prendre une image assez classique, si une recette de cuisine correspond au code source du programme, les tâches du cuisinier en train de préparer cette recette dans sa cuisine correspondent aux processus.

Création d'un processus

La création d'un processus peut intervenir

• au démarrage du système
• par un appel d'un autre processus
• par une action d'un utilisateur (lancement d'application)

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

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

Gérer les processus sur un système Linux

Il est possible de visualiser les processus grâce à la commande ps -eF.
Pour un affichage page par page, utilisez ps -eF | more

Un processus est caractérisé par un identifiant unique : son PID (Process Identifier).
Lorsqu'un processus engendre un fils, l'OS génère un nouveau numéro de processus pour le fils. Le fils connaît aussi le numéro de son père : le PPID (Parent Process Identifier).

Inspecter les processus en temps réel

Une commande indispensable à connaître sous Linux pour inspecter les processus est la commande top.

L'affichage se rafraîchit en temps réel contrairement à ps qui fait un instantané.
Voici quelques option qui s'activent s'activent par des raccourcis clavier. En voici quelques uns :

• h : affiche l'aide
• M : trie la liste par ordre décroissant d'occupation mémoire. Pratique pour repérer les processus trop gourmands
• P : trie la liste par ordre décroissant d'occupation processeur
• i : filtre les processus inactifs. Cela ne montre que ceux qui travaillent réellement.
• k : permet de tuer un processus - à condition d'en être le propriétaire.
• V : permet d'avoir la vue arborescente sur les processus.
• q : permet de quitter top

Terminer un processus

Pour tuer un processus, on lui envoie un signal de terminaison. On en utilise principalement deux :

• SIGTERM (15) : demande la terminaison d'un processus. Cela permet au processus de se terminer proprement en libérant les ressources allouées.
• SIGKILL (9) : demande la terminaison immédiate et inconditionnelle d'un processus. C'est une terminaison violente à n'appliquer que sur les processus récalcitrants qui ne répondent pas au signal SIGTERM.

Pour terminer proprement un processus :
vous lui enverrez donc un signal SIGTERM en tapant : la commande shell kill -15 PID où PID désigne le numéro du processus à quitter proprement.

Si ce dernier est planté et ne réagit pas à ce signal, alors vous pouvez vous en débarasser en tapant kill -9 PID.

III - Ordonnancement des processus

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

Un système d’exploitation multitâche ré-attribue périodiquement à l’UC une tâche différente dans le but de faire progresser l’exécution de plusieurs programmes à la fois.

• La notion d’ordonnancement de tâches est alors apparue.
• L’utilisateur a l’impression que plusieurs programmes sont exécutés « simultanément ».

Voici les différents états :

• Lorqu'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" (un coeur de processseur 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 à é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".
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 : Pour libérer une ressource, un processus doit obligatoirement être dans un état "élu".

Afin d'élire quel processus va repasser en mode "éluu", l'ordonnanceur applique un algorithme prédéfini lors de la conception de l'OS.
Le choix de cet algorithme va impacter directement la réactivité du système et les usages qui pourront en être fait.
C'est un élément critique du système d'exploitation.
Sous Linux, on peut passer des consignes à l'ordonnanceur en fixant des priorités aux processus dont on est propriétaire :
Cette priorité est un nombre NI entre -20 (plus prioritaire) et +20 (moins prioritaire).

Pour gérer l'élection d'un processus,on peut agir à 2 niveaux :

• fixer une priorité à une nouvelle tache dès son démarrage avec la commande nice
• modifier la priorité d'un processus en cours d'exécution grâce à la commande renice

les colonne PR et NI de la commande top montrent le niveau de priorité de chaque processus

Le lien entre PR et NI est simple : PR = NI + 20 ce qui fait qu'une priorité PR de 0 équivaut à un niveau de priorité maximal.

Exemple : Pour baisser la priorité du process terminator dont le PID est 21523, il suffit de taper : renice +10 21523

IV- Les threads

Nous avons vu comment une hiérarchie de processus se crée au fur et à mesure de l'utilisation de l'ordinateur, tous ayant pour racine le processus initial (systemd ou init sur les distributions linux).

Programmation séquentielle

Commençons par un programme simple :

#!/usr/bin/python3
def f1():
  for _ in range(5):
    print("Bonjour !")
    print("Comment vas-tu aujourd'hui ?")
    sleep(0.01)

def f2():
  for _ in range(5):
    print("Ça va ?")
	print()
    sleep(0.01)

f1()
f2()

Lorsque vous exécutez le programme, vous avez la fonction f1 qui s'éxécute complétement, puis ensuite la fonction f2 qui s'éxécute.
L'excecution des fonctions est dite séquentielle .

#!/usr/bin/python3
from threading import Thread
from time import sleep

def f1():
  for _ in range(5):
    print("Bonjour !")
    print("Comment vas-tu aujourd'hui ?")
    sleep(0.01)

def f2():
  for _ in range(5):
    print("Très bien")
    print("Merci et bonne journée.")
    sleep(0.01)

p1 = Thread(target=f1)
p2 = Thread(target=f2)
p1.start()
p2.start()
p1.join()
p2.join()

from threading import Thread
from time import sleep

p1 = Thread(target=f1)
p2 = Thread(target=f2)
p1.start()
p2.start()
p1.join()
p2.join()

#!/usr/bin/python3
from time import sleep

# Variable globale
compteur = 0 
limite = 400

def calcul():
  global compteur
  for c in range(limite):
    temp = compteur
    # simule un traitement nécessitant des calculs
    sleep(0.000000001)
    compteur = temp + 1

compteur = 0
calcul()
print(compteur)

#!/usr/bin/python3
from threading import Thread
from time import sleep

# Variable globale
compteur = 0 
limite = 100

def calcul():
  global compteur
  for c in range(limite):
	temp = compteur
	# simule un traitement nécessitant des calculs
	sleep(0.000000001)
	compteur = temp + 1

compteur = 0
mesThreads = []
for i in range(4): # Lance en parallèle 4 exécutions de calcul
  p = Thread(target = calcul)
  p.start()      # Lance calcul dans un processus léger à part.
  mesThreads.append(p)

# On attend la fin de l'exécution des threads.
for p in mesThreads :
	p.join()

print(compteur)

#!/usr/bin/python3
from threading import Thread,Lock
from time import sleep

# Variable globale
compteur = 0 
limite = 100
verrou = Lock()

def calcul():
  global compteur
  for c in range(limite):
	# Début de la section critique
	verrou.acquire()
	temp = compteur
	# simule un traitement nécessitant des calculs
	sleep(0.000000001)
	compteur = temp + 1
	# fin de la section critique
	verrou.release()
	
compteur = 0
mesThreads = []
for i in range(4): # Lance en parallèle 4 exécutions de calcul
  p = Thread(target = calcul)
  p.start()      # Lance calcul dans un processus léger à part.
  mesThreads.append(p)

# On attend la fin de l'exécution des threads.
for p in mesThreads :
	p.join()

print(compteur)

V- Interblocage (deadlock)

Lire la page

Je teste mes connaissances ...

• https://pixees.fr/informatiquelycee/
• https://www.lecluse.fr/
• lycee.educinfo.org