Cours Systèmes d’exploitation: Gestion des Processus

Ce cours traite de la gestion des processus dans les systèmes d’exploitation. Il s’adresse aux étudiants en informatique et technologies de l’information souhaitant comprendre les concepts fondamentaux liés aux processus, leur gestion, leur création, ainsi que les algorithmes d’ordonnancement utilisés par le système d’exploitation pour optimiser l’utilisation du processeur.

Processus

Un processus est un ensemble d'octets en langage machine en cours d'exécution. Il correspond à l’exécution d’un programme par le système d’exploitation. Contrairement au programme exécutable, qui est un fichier statique sur disque, le processus est une entité dynamique qui comprend :

• la suite d’instructions en cours d’exécution,
• les données associées,
• la pile d’exécution,
• le compteur ordinal (adresse de la prochaine instruction à exécuter),
• le pointeur de pile et les registres nécessaires.

Le processus est le concept de base de tout système d’exploitation.

Multiprogrammation

Un système d’exploitation exécute généralement plusieurs programmes simultanément. Comme il dispose souvent d’un seul processeur, il crée un pseudo-parallélisme en traitant une tâche à la fois, en s’interrompant rapidement pour passer à la suivante. Cette commutation rapide donne l’illusion d’un traitement simultané. La multiprogrammation repose donc sur le basculement rapide du processeur entre plusieurs processus, chacun s’exécutant pendant de courtes périodes.

Généalogie des processus

Un processus est généralement créé par un autre processus, appelé « père ». Les processus créés sont appelés « fils ». Cette relation crée une structure arborescente des processus. Au démarrage du système, un seul processus existe, appelé « init », qui est l’ancêtre de tous les autres processus et n’a pas de père.

Commandes utiles :

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

Espace mémoire d’un processus

L’espace mémoire d’un processus est divisé en trois segments accessibles par les programmes utilisateur :

• le segment de code (instructions exécutables),
• le segment des données (variables globales, statiques),
• la pile (stack) utilisée pour les appels de fonctions et variables locales.

Chaque processus possède son propre compteur ordinal, ses registres et ses variables, ce qui lui permet d’exécuter son programme indépendamment des autres.

Table des processus

Le noyau maintient une table des processus en mémoire, contenant des informations sur tous les processus actifs (P1, P2, ...). Cette table est limitée en taille, ce qui limite le nombre de processus simultanés.

Contexte d’un processus

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

1. l’état du processus,
2. le mot d’état (PSW) contenant la valeur des registres actifs et le compteur ordinal,
3. les variables globales, statiques ou dynamiques,
4. l’entrée dans la table des processus,
5. la zone utilisateur (zone u),
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, une commutation de contexte est réalisée pour sauvegarder l’état du processus interrompu et charger celui du nouveau processus.

Commutation de mot d’état et interruptions

Pour exécuter un processus, le programme et ses données doivent être chargés en mémoire centrale. L’unité centrale (CPU) exécute les instructions en utilisant plusieurs registres :

• accumulateur (résultat d’une instruction),
• registre d’instruction (instruction en cours),
• compteur ordinal (adresse de la prochaine instruction),
• registre d’adresse,
• registres de données (pour lire/écrire en mémoire),
• registres d’état du processeur (mode user/system, interruptions, etc.),
• registres d’état du processus (droits, adresses, priorités).

Ces registres forment le contexte d’unité centrale du processus. Lorsqu’un nouveau processus doit être exécuté, le système sauvegarde le mot d’état du processus courant et charge celui du nouveau processus, ce qui s’appelle la commutation de mot d’état. Cette opération utilise deux adresses : celle de sauvegarde et celle de lecture du mot d’état.

Interruptions

Une interruption est une commutation de mot d’état provoquée par un signal matériel, résultant 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 via un vecteur d’interruptions.

Types d’interruptions :

• externes : interventions de l’opérateur, pannes, etc.,
• déroutements : erreurs internes comme division par zéro, dépassement mémoire,
• appels systèmes : demandes d’entrée-sortie, etc.

Chaque interruption a une priorité, l’horloge étant la plus prioritaire sous Unix.

Processus et système d’exploitation

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

• le partage des ressources (processeur, mémoire, stockage),
• l’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 Windows,
• Gestionnaire de tâches Linux.

Bloc de contrôle processus (PCB)

Le PCB est une structure de données du système d’exploitation contenant toutes les informations sur un processus. Cette zone mémoire est accessible uniquement par le noyau. Pour obtenir des informations sur un processus, il faut passer par des appels systèmes tels que getpid, getppid, getuid, etc.

Informations contenues dans le PCB

1. Identité :
   • Identificateur de processus (PID) unique à un instant donné,
   • Informations de généalogie : PID du parent (PPID), processus enfants,
   • Informations de droits : utilisateur propriétaire, utilisateur effectif (droits d’administration locaux, serveurs, etc.).
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, temps utilisateur),
   • Liste des fichiers ouverts (fichiers, périphériques, pipes),
   • Autres ressources utilisées.

Exemple simplifié d’un processus

Un processus avec le numéro 36, lancé par un utilisateur avec UID 106, exécute le programme 'cmd1'. Il a consommé 0.3 seconde, 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 standard d’erreur.

É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 alloué, il retourne en file d’attente des prêts. 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 (processus init, id=0),
• par un autre processus (processus père),
• par une requête utilisateur (commande),
• par un traitement par lot.

La destruction d’un processus peut avoir plusieurs causes :

• arrêt normal (fin de tâche),
• arrêt volontaire suite à une erreur (instruction illégale),
• arrêt involontaire (paramètres incorrects),
• arrêt demandé par un autre processus.

Création des processus sous Windows

L’appel système CreateProcess crée un processus avec des caractéristiques passées en paramètres (10 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 des processus sous Unix

L’appel système fork() duplique le processus courant avec toutes ses informations (copie mémoire, PID et PPID changent). Les deux processus s’exécutent parallèlement, sans garantie de l’ordre d’exécution. fork() retourne 0 dans le fils et le PID du fils dans le père.

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

Pour que le fils exécute un autre programme, 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 :

• optimiser l’utilisation du processeur,
• augmenter le nombre de processus exécutés,
• minimiser le temps moyen d’exécution et d’attente,
• minimiser les temps d’inactivité du processeur.

Algorithmes d’ordonnancement

Les performances se mesurent par :

• 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 = 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.

Premier venu premier servi (FCFS)

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

Exemple :

Processus	Temps CPU
P1	25
P2	3
P3	11

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

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

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

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

Avantages : simple, faible surcoût, équitable, efficace en multiprocesseurs pour processus bloqués.

Inconvénients : temps de réponse dépend du premier processus, pénalise les processus courts.

Travail le plus court d’abord (SJF)

Algorithme non préemptif qui donne la main au processus avec le plus court temps d’exécution estimé. En cas d’égalité, FCFS est utilisé.

Exemple :

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

Temps restant le plus court (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 courant est interrompu.

Exemple :

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

Tourniquet (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 avec quantum = 2 unités :

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

Temps d’attente moyen = 3,31 unités.

Ordonnancement avec priorité

Chaque processus a une priorité. Le processus le plus prioritaire s’exécute en premier. La priorité est généralement croissante et l’ordonnancement est préemptif.

Exemple :

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

Glossaire des termes clés

• Processus : Entité dynamique correspondant à l’exécution d’un programme avec ses données et contexte.
• Programme : Fichier statique contenant des instructions exécutables.
• Multiprogrammation : Technique permettant d’exécuter plusieurs processus en pseudo-parallèle sur un seul processeur.
• Contexte d’un processus : Ensemble des données nécessaires pour reprendre l’exécution d’un processus interrompu.
• Commutation de contexte : Opération de sauvegarde et restauration du contexte lors du changement de processus.
• Interruption : Signal matériel provoquant une commutation de contexte pour gérer un événement.
• PCB (Process Control Block) : Structure mémoire contenant toutes les informations sur un processus.
• Ordonnanceur : Composant du système d’exploitation qui choisit quel processus exécuter.
• Algorithme FCFS : Ordonnancement non préemptif selon l’ordre d’arrivée.
• Algorithme SJF : Ordonnancement non préemptif favorisant les processus les plus courts.
• Algorithme SRT : Version préemptive de SJF basée sur le temps restant.
• Algorithme Round Robin : Ordonnancement préemptif avec quantum de temps fixe.
• Priorité : Critère d’ordonnancement où le processus le plus prioritaire est exécuté en premier.

Points clés à retenir

• Un processus est un programme en cours d’exécution avec son propre contexte.
• La multiprogrammation permet de simuler l’exécution simultanée sur un processeur unique.
• Le noyau gère les processus via une table et réalise des commutations de contexte pour passer d’un processus à un autre.
• Les interruptions sont des événements matériels qui déclenchent des changements de contexte.
• Les processus peuvent être créés par le système, par un autre processus ou par l’utilisateur.
• Différents algorithmes d’ordonnancement existent, chacun avec ses avantages et inconvénients selon le contexte.
• Le PCB contient toutes les informations nécessaires pour gérer un processus.
• La gestion efficace des processus est essentielle pour la performance et la réactivité du système.