Cours Systèmes d’exploitation: Gestion des Processus

Ce cours couvre la gestion des processus dans les systèmes d’exploitation, destiné aux étudiants en informatique et technologies de l’information. Il présente les concepts fondamentaux liés aux processus, leur création, gestion, ordonnancement, ainsi que les mécanismes d’interruption et de communication inter-processus.

Processus

Un processus est l'exécution dynamique d'un programme par le système d’exploitation. Il s'agit d'une entité dynamique composée d'une suite d'instructions en cours d'exécution, accompagnée de ses données, de sa pile, de son compteur ordinal, de son pointeur de pile et des registres nécessaires. Il ne faut pas confondre un processus (aspect dynamique) avec un programme exécutable (fichier statique sur disque).

Multiprogrammation

Un système d’exploitation exécute généralement plusieurs programmes simultanément, même s’il ne dispose que d’un seul processeur. Il simule le parallélisme en traitant une tâche à la fois, en s’interrompant rapidement pour passer à la suivante. Ce basculement rapide entre processus donne l’illusion d’un traitement simultané. La multiprogrammation repose donc sur la commutation rapide de la CPU entre plusieurs processus pendant de courtes périodes.

Généalogie des processus

Un processus est souvent créé par un autre processus, appelé « père », tandis que les processus créés sont appelés « fils ». Cette relation forme une arborescence de processus. Au démarrage du système, un seul processus existe, appelé « init », qui est l’ancêtre de tous les autres et n’a pas de père.

Commandes utiles :

• ps : liste des processus
• pstree : affiche l’arborescence des processus

Espace mémoire d’un processus

Chaque processus possède un espace mémoire d’adressage divisé en trois segments accessibles par les programmes utilisateur. Un processus comprend :

• Son propre compteur ordinal (adresse de la prochaine instruction)
• Ses registres
• Ses variables

Le noyau maintient une table des processus en mémoire, contenant des informations sur chaque processus actif. Cette table a une taille limitée par système et utilisateur.

Contexte d’un processus

Le contexte d’un processus est l’ensemble des données permettant de reprendre son exécution après une interruption. Il comprend :

1. Son état
2. Son mot d’état (PSW) comprenant la valeur des registres actifs et le compteur ordinal
3. Les variables globales statiques ou dynamiques
4. Son entrée dans la table des processus
5. Sa zone utilisateur
6. Les piles utilisateur et système
7. Les zones de code et de données

Le noyau et ses variables ne font pas partie du contexte d’un processus. Lors d’un changement de processus courant, une commutation de mot d’état et de contexte est réalisée, et le noyau s’exécute dans le nouveau contexte.

Commutation de mot d’état et interruptions

La commutation de mot d’état est une opération fondamentale qui consiste à sauvegarder le contexte d’unité centrale du processus courant et à charger celui du nouveau processus à exécuter. L’unité centrale contient plusieurs registres :

• Accumulateur : reçoit le résultat d’une instruction
• Registre d’instruction : contient l’instruction en cours
• Compteur ordinal : adresse de la prochaine instruction
• Registre d’adresse
• Registres de données
• Registres d’état du processeur : mode, retenue, vecteur d’interruptions, etc.
• Registres d’état du processus : droits, adresses, priorités, etc.

Ces registres forment le contexte d’unité centrale d’un processus. La commutation utilise deux adresses : une pour sauvegarder le mot d’état actuel, l’autre pour charger le nouveau mot d’état. Ainsi, un processus interrompu peut reprendre son exécution exactement là où il s’était arrêté.

Interruptions

Une interruption est une commutation de mot d’état provoquée par un signal matériel, conséquence d’un événement extérieur ou intérieur. Ce signal modifie un indicateur testé régulièrement par l’unité centrale. La cause de l’interruption est déterminée par un vecteur d’interruptions.

Types d’interruptions :

• Externes : interventions de l’opérateur, pannes, etc.
• Déroutements : erreurs internes (débordement mémoire, division par zéro, etc.)
• Appels systèmes : demandes d’entrée-sortie, etc.

Chaque interruption est associée à un niveau de priorité pour gérer l’ordre de traitement. Par exemple, l’horloge est l’interruption la plus prioritaire sur un système Unix.

Processus et système d’exploitation

Plusieurs processus indépendants doivent pouvoir s’exécuter sans interférence, ce qui implique :

• Partage des ressources (processeur, mémoire, stockage)
• Isolation des processus pour la sécurité et la fiabilité

Inversement, les processus doivent pouvoir communiquer si nécessaire via des mécanismes de Communication Inter-Processus (IPC).

Informations sur les processus

Les systèmes d’exploitation fournissent des outils pour visualiser les processus :

• Gestionnaire de tâches sous Windows
• Gestionnaire de tâches sous Linux

Bloc de contrôle de processus (PCB)

Le PCB est une structure de données du système d’exploitation contenant toutes les informations sur un processus. Ces données sont accessibles uniquement par le noyau. Pour obtenir des informations sur un processus, il faut utiliser des appels systèmes comme getpid, getppid, getuid, seteuid, setuid, etc.

Informations contenues dans le PCB

1. Identité
   • Identificateur de processus (PID) : numéro unique temporaire
   • Généalogie : PID du parent (PPID), liste des enfants
   • Droits : utilisateur propriétaire, utilisateur effectif, droits d’administration
2. Exécution
   • État du processus
   • Contexte processeur : état des registres
   • Informations d’ordonnancement (exemple : priorité)
3. Ressources
   • Informations sur la mémoire utilisée (tables de pages)
   • Temps passé : temps réel d’exécution, temps utilisateur
   • Liste des fichiers ouverts (fichiers, périphériques, pipes)
   • Autres ressources utilisées

Exemple simplifié d’un processus

Un processus exécute le programme cmd1. Il porte le numéro 36, a été lancé par un utilisateur avec l’UID 106. Il a consommé 0,3 seconde CPU, avec une priorité de 20. Son masque de création de fichier est 027, son terminal de contrôle est /dev/term/c4 et son répertoire courant est /usr/c1.

Les descripteurs standards sont :

• 0 : entrée standard
• 1 : sortie standard
• 2 : sortie d’erreur standard

États d’un processus

Les systèmes d’exploitation définissent au minimum trois états :

• Élu ou Actif : le processus est en cours d’exécution. S’il épuise son temps CPU, il retourne en état prêt. S’il attend une ressource, il passe en état bloqué.
• Eligible ou Prêt : le processus attend de pouvoir s’exécuter.
• Bloqué ou En attente : le processus attend un événement ou une ressource. Dès que celle-ci est disponible, il repasse en état prêt.

Création des processus

Un processus peut être créé :

• Au démarrage du système, avec la création automatique du processus racine (id=0)
• Par un autre processus (le père), qui devient le parent du nouveau processus (le fils)
• Par une requête utilisateur (commande)
• Par initiation d’un travail en traitement par lot

La destruction d’un processus peut être causée par :

• Arrêt normal (fin de tâche)
• Arrêt volontaire suite à une erreur (instruction illégale)
• Arrêt involontaire pour erreur fatale (mauvais paramètres)
• Arrêt volontaire par un autre processus

Création sous Windows

L’appel système CreateProcess crée un processus avec plusieurs paramètres. Exemple :

STARTUPINFO si; // à renseigner
PROCESS_INFORMATION pi; // utilisé en sortie
bool succes = CreateProcess(0, "mon_prog.exe", 0, 0,
FALSE, 0, 0, 0, &si, &pi);

Création sous Unix

L’appel système fork() duplique le processus courant, créant un fils avec une copie de la mémoire du père (seuls PID et PPID changent). Les deux processus s’exécutent en parallèle, sans garantie d’ordre d’exécution.

Exemple :

int pid_fils = fork();
if (pid_fils == 0) // fils
else // père

Pour que le fils exécute un programme différent, on utilise exec :

int pid_fils = fork();
if (pid_fils == 0) exec("chemin d’un autre programme");

Ordonnancement des processus

L’ordonnanceur choisit parmi les processus prêts celui qui va s’exécuter sur le processeur. Les objectifs sont :

• Maximiser l’utilisation du processeur
• Augmenter le nombre de processus exécutés
• Minimiser le temps moyen d’exécution
• Minimiser le temps d’attente
• Réduire les temps d’inactivité du processeur

Algorithmes d’ordonnancement

Quelques indicateurs de performance :

• Temps de rotation d’un processus = date de fin - date d’arrivée
• Temps de rotation moyen = somme des temps de rotation / nombre de processus
• Temps d’attente d’un processus = temps de rotation - durée d’exécution
• Temps moyen d’attente = somme des temps d’attente / nombre de processus
• Rendement = durée totale d’exécution / nombre de processus

1. First Come First Serve (FCFS)

Ordonnancement non préemptif, géré par une file FIFO. Le processeur est alloué au processus en tête de file.

Exemple :

Processus	Temps CPU
P1	25
P2	3
P3	11

Ordre d’exécution : P1 ; P2 ; P3

Temps d’attente :

• P1 : 0
• P2 : 25
• P3 : 28

Temps d’attente moyen = (0 + 25 + 28) / 3 = 17,66

Si on change l’ordre d’exécution en P2 ; P3 ; P1 :

• P1 : 14
• P2 : 0
• P3 : 3

Temps d’attente moyen = (14 + 0 + 3) / 3 = 5,66

Avantages :

• Simple, faible surcoût, équitable
• Efficace en multi-processeurs pour processus souvent bloqués (E/S)

Inconvénients :

• Temps de réponse dépend du processus en cours
• Pénalise les processus courts

2. Shortest Job First (SJF)

Ordonnancement non préemptif qui donne la priorité au processus avec le plus court temps d’exécution estimé. En cas d’égalité, FCFS est utilisé. Hypothèse forte : connaissance du temps d’exécution.

Exemple :

Processus	Temps d’arrivée	Temps CPU
P1	0	5
P2	2	2
P3	4	1

Schéma d’exécution à construire selon la règle SJF.

3. Shortest Remaining Time (SRT)

Version préemptive de SJF. L’ordonnanceur compare le temps restant du processus en cours avec le temps d’un nouveau processus arrivé. Si le nouveau est plus court, le processus en cours est interrompu.

Exemple :

Processus	Temps d’arrivée	Temps CPU
P1	0	5
P2	1	3
P3	2	1

Schéma d’exécution à construire selon la règle SRT.

4. Round Robin (RR)

Algorithme FCFS avec préemption. Chaque processus reçoit un quantum de temps. À la fin du quantum, s’il n’est pas terminé, il retourne en file d’attente.

Exemple :

Processus	Temps d’arrivée	Temps CPU
P1	0	2
P2	1	4
P3	3	3

Quantum = 2 unités

Ordre d’exécution :

P1 (0-2) → P2 (2-4) → P3 (4-6) → P2 (6-8) → P3 (8-9)

Temps d’attente :

• P1 : 0
• P2 : 1,97 + 2 = 3,97
• P3 : 3,96 + 2 = 5,96

Temps d’attente moyen = 9,93 / 3 = 3,31 unités

Question : que se passe-t-il si le temps CPU de P1 passe à 5 ?

5. Algorithme avec priorité

Chaque processus possède une priorité. Le processus avec la priorité la plus élevée s’exécute en premier. La priorité est généralement préemptive et croissante (plus la valeur est élevée, plus la priorité est haute).

Processus	Temps d’arrivée	Temps CPU	Priorité
P1	0	6	3
P2	1	5	4
P3	4	3	2
P4	4	4	5

Deux cas :

• Priorité avec préemption
• Priorité sans préemption

Glossaire des termes clés

• Processus : entité dynamique correspondant à l’exécution d’un programme.
• Multiprogrammation : technique permettant d’exécuter plusieurs processus en simulant le parallélisme.
• Compteur ordinal : registre contenant l’adresse de la prochaine instruction à exécuter.
• Contexte d’un processus : ensemble des données nécessaires pour reprendre un processus interrompu.
• Commutation de mot d’état : sauvegarde et chargement des contextes des processus lors d’un changement d’exécution.
• Interruption : signal matériel provoquant une commutation de contexte.
• PCB (Process Control Block) : structure contenant les informations sur un processus.
• État d’un processus : statut du processus (actif, prêt, bloqué).
• Ordonnancement : processus de sélection du prochain processus à exécuter.
• Préemption : interruption d’un processus en cours pour en exécuter un autre.
• Quantum : durée maximale d’exécution allouée à un processus dans l’algorithme Round Robin.
• IPC (Communication Inter-Processus) : mécanismes permettant aux processus de communiquer.

Points clés à retenir

• Un processus est une entité dynamique distincte d’un programme statique.
• La multiprogrammation repose sur la commutation rapide entre processus pour simuler le parallélisme.
• Le contexte d’un processus inclut ses registres, variables, état et informations de gestion.
• La commutation de mot d’état permet de sauvegarder et restaurer le contexte des processus.
• Les interruptions sont des signaux matériels qui déclenchent des changements de contexte.
• Les processus sont organisés en arborescence avec des relations père-fils.
• Plusieurs algorithmes d’ordonnancement existent, chacun avec ses avantages et inconvénients.
• La préemption permet de garantir la réactivité dans les systèmes multitâches.
• Le PCB est la structure centrale pour la gestion des processus par le noyau.
• La communication et l’isolation des processus sont essentielles pour la sécurité et la fiabilité.