Hoja de repaso: Gestion des processus et threads sous Linux

📋 Plan du Cours

1. Processus et contexte d'exécution
2. États et transitions d'un processus
3. Processus sous Linux
4. Création, terminaison et attente
5. Remplacement d'espace d'adressage
6. Threads et fil principal
7. Gestion des threads sous Linux

📖 1. Processus et contexte d'exécution

🔑 Notions clés & Définitions

• Contexte du processus : Le contexte du processus regroupe les informations nécessaires pour exécuter le processus à l’instant courant sur le processeur et pour gérer sa mémoire.
• Environnement mémoire : L’environnement mémoire d’un processus correspond aux zones de code, de données et de pile qui contiennent l’état nécessaire à l’exécution.
• Environnement processeur : L’environnement processeur d’un processus rassemble les éléments matériels et registres (CO, PSW, registres) utilisés lors de l’exécution.

📝 Points essentiels

• Un processus est un programme en cours d’exécution associé à un environnement mémoire (code, données, pile) et à un environnement processeur (CO, PSW, registres).
• Les deux environnements constituent le contexte du processus nécessaire pour le reprendre et l’exécuter.

💡 Astuce mémo

Contexte = Mémoire (code/données/pile) + Processeur (CO/PSW/registres).

📖 2. États et transitions d'un processus

🔑 Notions clés & Définitions

• Prêt : L’état Prêt correspond à un processus qui attend l’accès au processeur sans s’exécuter actuellement.
• Élu : L’état Élu correspond à un processus actuellement exécuté par le processeur.
• Bloqué : L’état Bloqué correspond à un processus qui attend une ressource autre que le processeur.

📝 Points essentiels

• Les états décrits sont Nouveau, Prêt, Élu et Bloqué pendant l’exécution d’un processus.
• La transition d’élection se produit quand le processeur devient libre et qu’un processus prêt est sélectionné par l’ordonnanceur.
• La transition de blocage arrive quand le processus élu demande une ressource et quitte le processeur pour devenir bloqué.
• La transition de déblocage est déclenchée quand la ressource attendue par le processus bloqué devient disponible.
• La transition de réquisition correspond au retrait du processeur par l’ordonnanceur puis à l’allocation à un autre processus prêt, par exemple à la fin d’un quantum.

💡 Astuce mémo

Élu→Bloqué par demande de ressource ; Bloqué→Prêt quand la ressource arrive ; Prêt→Élu par élection ; Élu→Prêt par réquisition.

📖 3. Processus sous Linux

🔑 Notions clés & Définitions

• Bootstrap : Le bootstrap est le programme chargé depuis la ROM au démarrage, qui initialise une partie du système d’exploitation en mémoire pour créer le processus 0.
• Init : Init est un processus identifié par pid 1, qui crée d’autres processus et adopte ceux dont le père a disparu.
• Démons : Les démons sont des processus créés au démarrage avec pid 2, issus du processus 0.

📝 Points essentiels

• Au démarrage, le bootstrap charge une partie du SE en RAM pour créer le processus 0.
• Le processus 0 crée deux processus : Init de pid 1 et Démons de pid 2.
• Chaque processus a un père, et si le père disparaît, le processus est adopté par le processus Init.
• Le schéma de démarrage inclut bootstrap puis Init, ainsi que des processus de type login/getty menant vers le shell.

💡 Astuce mémo

Démarrage : Bootstrap→processus 0→Init(pid 1) + Démons(pid 2).

📖 4. Création, terminaison et attente

🔑 Notions clés & Définitions

• fork() : fork() est l’appel système qui crée un nouveau processus en dupliquant le code et les données du processus père.
• exit() : exit() est l’appel système utilisé pour terminer volontairement un processus en signalant un statut.
• wait() : wait() est l’appel système permettant au père d’attendre la terminaison d’un fils ou de vérifier si un fils est terminé.

📝 Points essentiels

• fork() est utilisé par le père et retourne -1 en cas d’échec, zéro dans le fils et une valeur positive correspondant au PID du fils dans le père.
• Lorsqu’un fils se termine, son état de terminaison est enregistré dans son PCB puis le processus passe à l’état Zombie tandis que des ressources sont libérées.
• Un processus peut se terminer via exit(), via un signal kill reçu (arrêt forcé) ou via une erreur.
• wait(state) bloque l’appelant jusqu’à la fin d’un de ses fils et détruit ensuite le PCB du fils une fois la mort connue.
• Le code retour de wait est le PID du fils terminé et waitpid(p,state,0) avec p>0 bloque jusqu’à la fin du fils de PID p.

💡 Astuce mémo

fork sépare : fils reçoit 0, père reçoit le PID ; wait récupère : retour = PID du fils terminé.

📖 5. Remplacement d'espace d'adressage

🔑 Notions clés & Définitions

• exec : exec est une famille d’appels système qui remplace le code exécutable du processus courant par un autre programme, sans créer de nouveau processus.
• Recouvrement en mémoire : Le recouvrement en mémoire décrit l’écrasement de la zone mémoire associée au code et aux données par celles du nouveau programme chargé via exec.
• execlp : execlp est une forme d’exec qui lance un programme à partir de son nom et des arguments, utilisée pour montrer l’effet de remplacement.

📝 Points essentiels

• Linux propose une famille d’appels système exec pour remplacer le code d’un processus par un autre programme fourni via un path ou un fichier en paramètre.
• En cas de succès, l’ancien code est remplacé et le processus poursuit son exécution avec le nouveau programme, sans création d’un nouveau processus.
• En cas d’échec d’exec, le processus continue l’exécution à partir de l’instruction qui suit l’appel, ce qui permet de voir les sorties « Hello 2 » dans l’exemple.
• Dans l’exemple avec fork puis execlp de ls -l, le processus conserve son PID, son espace mémoire alloué, sa table de descripteurs de fichier et ses liens parentaux.

💡 Astuce mémo

Succès exec : “Hello 1 puis Hello 3/4” ; échec exec : “Hello 1 puis Hello 2” (on ne remplace pas).

📖 6. Threads et fil principal

🔑 Notions clés & Définitions

• Thread principal : Le thread principal est le fil d’exécution qui commence par exécuter le programme main dans un processus.
• Fil d’exécution : Le fil d’exécution désigne l’unité d’exécution d’un processus, utilisée ici pour parler du thread démarrant à partir de main.
• Thread : Un thread est une unité rattachée à un processus qui exécute une partie du traitement (une fonction) en concurrence avec le reste.

📝 Points essentiels

• En C, l’exécution débute par main, appelé aussi thread principal, qui sert de fil d’exécution dans le processus.
• Un thread s’exécute en concurrence avec le processus lourd, et un processus peut devenir multithread avec plusieurs fils d’exécution.
• Le code, les données, les registres et la pile peuvent être associés aux différents threads, ce qui explique la séparation des contextes d’exécution internes.

💡 Astuce mémo

Un processus démarre avec main : c’est le fil principal, puis on ajoute des threads.

📖 7. Gestion des threads sous Linux

🔑 Notions clés & Définitions

• pthread_create() : pthread_create() crée un thread en lui attribuant une fonction à exécuter et un argument, avec des attributs éventuels.
• pthread_join() : pthread_join() attend la fin d’un thread spécifique en récupérant éventuellement un état de terminaison via status.
• pthread_exit() : pthread_exit() termine l’exécution du thread appelant et peut fournir une valeur de sortie.

📝 Points essentiels

• pthread_create(tid, attr, nomFonction, arg) crée un thread qui exécute nomFonction avec arg, et NULL pour attr signifie des valeurs par défaut.
• pthread_join(tid, status) suspend le thread appelant jusqu’à la fin du thread identifié par tid, analogue à waitpid mais ciblé sur les threads.
• pthread_exit(valeur) termine un thread en retournant une valeur de terminaison.
• Dans l’exemple, le thread créé exécute presentation(), puis appelle pthread_exit(NULL) pour se terminer pendant que le thread principal affiche après pthread_join.

💡 Astuce mémo

create pour lancer, join pour attendre, exit pour sortir.

⚠️ Pièges & confusions fréquents

1. Confondre l’état Bloqué avec l’état Prêt : Bloqué attend une ressource autre que le processeur, Prêt attend seulement le processeur.
2. Croire que exec crée un nouveau processus : en cas de succès, il remplace le code et les données du processus courant.
3. Mélanger fork et exec : fork duplique père et fils, tandis qu’exec remplace le programme dans le même processus.
4. Se tromper sur fork() : dans le fils le retour est 0, dans le père le retour est une valeur positive égale au PID du fils.
5. Oublier le comportement de wait : wait bloque jusqu’à la fin d’un fils puis fournit le PID du fils terminé, plutôt qu’un simple statut booléen.
6. Confondre pthread_join avec un équivalent wait sans identifiant : pthread_join impose le tid du thread à attendre.

✅ Checklist Examen

1. Définir un processus et citer les deux environnements qui composent son contexte (mémoire et processeur).
2. Donner les états possibles d’un processus (Nouveau, Prêt, Élu, Bloqué) et caractériser Prêt, Élu et Bloqué.
3. Décrire les transitions : élection, blocage, déblocage et réquisition, et dire ce qui déclenche chacune.
4. Expliquer le rôle du bootstrap au démarrage et donner les pids indiqués pour Init et Démons.
5. Relier la création de processus à fork() et donner les valeurs de retour (-1, 0, PID positif).
6. Expliquer trois voies de terminaison d’un processus : exit(), kill/signal forcé, ou erreur, et préciser l’état Zombie pour un fils.
7. Décrire wait() : qu’il bloque, quel est son type d’information (PID du fils) et le rôle de destruction du PCB.
8. Comparer wait et waitpid(p,state,0) avec p>0 en précisant l’effet de blocage jusqu’au fils de pid p.
9. Décrire exec : remplacer le programme sans création d’un nouveau processus et évoquer le recouvrement en mémoire (code et données).
10. Donner la différence de comportement exec en cas de succès vs échec en s’appuyant sur la poursuite à l’instruction suivante.
11. Expliquer l’idée d’écrasement du code hérité dans l’exemple fork puis execlp, et mentionner la conservation du PID et de la table de descripteurs.
12. Définir le thread principal et préciser qu’il correspond à main dans le processus.
13. Définir ce qu’est un thread et dire qu’il s’exécute en concurrence au sein du processus.
14. Citer et interpréter les signatures et rôles de pthread_create, pthread_join et pthread_exit (création, attente, terminaison).