Chapitre 2 : Gestion des Processus (vs Processeur)

Chapitre 2 : Gestion des Processus (vs Processeur)

1. Introduction : L’unité centrale (UC) représentée par le Processeur est la ressource la plus importante du système, et sa bonne gestion est absolument cruciale pour son bon fonctionnement. La gestion de l’UC a pour objectif l’allocation efficace du temps UC aux processus en attente d’exécution. Cette allocation peut encore se définit comme une fonction d’ordonnancement de processus selon des critères établis.

2. Concepts de base :

2.1.Définition : La chaîne de production d’un programme transforme un programme écrit dans un langage de haut niveau en un programme dit exécutable, écrit en langage machine. Ce programme exécutable est stocké sur une unité secondaire de stockage (un disque dur par exemple). À l’issue de son chargement, il sera placé en mémoire centrale pour pouvoir être exécuté (c’est la condition principale pour que le programme passe à l’exécution), à ce niveau-là, il va être appelé un Processus.

On définit de manière simple et précise, un Processus comme un objet système qui représente l’exécution d’un programme (que ce soit un programme utilisateur ou un programme système). On voudrait souligner au travers cette définition les points importants suivants :

(1) Un processus est une entité dynamique (programme + contexte), dont l’état évolue en fonction du temps, qui nait avec le début de l’exécution d’un programme et qui meurt à la fin de son exécution,

(2) On fait une distinction entre un programme qui est une suite d’instructions par nature (Objet statique) et un processus du système (objet dynamique).

Le coté intéressant de ce raisonnement est que rien n’interdit de démarrer plusieurs processus à partir d’un même programme (du même code) ; Chaque exécution d’un même programme donne lieu à un nouveau processus différent. Exemple : ouvrir plusieurs fichiers Word, Page web, etc. chacun des processus démarrés représentera une exécution particulière du programme (instance dynamique). On dit alors que le code est partagé par plusieurs processus.

2.2.Etats d’un processus : L’aspect dynamique d’un processus implique que celui-ci n’a pas une existence perpétuelle et donc qu’il est créé à un instant donné, qu’il vit pour une certaine durée finie, et enfin, qu’il meurt. Durant sa vie (son cycle de vie), le processus passe par un certain nombre d’états, sous certaines conditions :

• Nouveau : Cet état exprime le fait qu’il y ait un processus nouvellement créé dans le système ; il est chargé au niveau de la mémoire centrale et possède son propre PCB¹ (Voir plus de détails concernant cette structure de données dans la section 2.3).

• Prêt : Eligible ou En attente d’exécution (ou bien Ready en anglais). Comme les ressources du système sont en nombre limité, il n’est pas possible d’attribuer à chaque processus (dès sa création) toutes les ressources dont il aura besoin. Une ressource peut être matérielle (unité centrale, périphériques, etc.) ou logicielle (variable partagée, fichier, BD, etc.). A chaque type de ressource est associée dans le système une procédure d’allocation dont à chaque ressource correspond un descripteur. Le descripteur se réduit à un bit représentant l’état libre ou alloué de la ressource.

Donc, l’état Prêt d’un processus exprime le fait qu’il possède toutes les ressources² nécessaires à son exécution (à l’exception du processeur) ainsi que son PCB est inséré dans la file d’attente des processus prêts.

• Actif : Elu ou En exécution (ou bien Running en anglais). Cet état caractérise donc un processus qui est en possession du processeur (on dit également qu’il prend le contrôle du processeur).

• Bloqué : en attente de la fin d’une opération d’E/S.

• Terminé : il est sur le point de quitter le système (après une fin normale ou anormale). Cet état exprime le fait que le système pourra récupérer les ressources de ce processus pour les réallouer à un autre processus.

Figure 1 : Diagramme d’états de processus

Ce diagramme d’états représente bien le comportement dynamique d’un processus à travers son cheminement d’état en état, depuis sa naissance jusqu’à sa fin. L’état ‘Actif’ est le plus complexe des états car il représente le concept de la Multiprogrammation : il

1 Process Control Block

2 https://fr.wikipedia.org/wiki/Ressource_(informatique)

T1

T5

T2

T4

T3

T6 Actif (Elu) Prêt

Bloqué

Nouveau Terminé

exprime le fait que plusieurs processus peuvent se trouver en attente du processeur mais qu’un seul processus pourra s’exécuter à la fois (en supposant que l’on dispose d’un seul processeur partagé entre plusieurs processus, on parle ici de la Multiprogrammation et non pas de Multiprocesseurs).

La figure 1 montre les différentes transitions : T1, T2, T3, T4, T5 et T6 ainsi que les événements associés à ces transitions qui sont définis comme suit :

- T1: le système a alloué les ressources nécessaires à l’exécution du processus à l’exception du processeur s’il n’est pas libre.

- T2 : le processeur est alloué au processus.

- T3: le processus a émis un appel (une demande) système pour se mettre en attente d’une opération d’E/S.

- T4 : le processus a été interrompu par un autre processus plus prioritaire ou qu’il a commis une erreur durant son exécution (ce dernier cas soit traité si le processus dispose d’un mécanisme de défense³).

- T5: l’opération d’E/S demandé par le processus vient de s’achever.

- T6: le processus a émis un appel de fin d’exécution (départ volontaire) ou bien a commis une erreur durant son exécution (départ obligatoire si le processus ne dispose pas d’un mécanisme de défense).

2.3.Bloc de Contrôle de Processus : La représentation d’un processus dans le système se fait de façon unique à l’aide d’une structure de donnée appropriée, dite PCB : Process Control Block. Le PCB est en fait une table qui contient toutes les informations nécessaires à l’exécution d’un processus. Ces informations servent à démarrer ou redémarrer l’exécution d’un processus. Lorsqu’un processus est temporairement suspendu (interruption ou demande d’E/S), il faut qu’il puisse retrouver l’état où il se trouvait au moment de sa suspension ; il faut que toutes les informations dont il a besoin soient sauvegardées pendant sa mise en attente, donc c’est dans ce PCB que le système va sauvegarder ces informations de reprise pour assurer l’opération de redémarrage.

Dans le système, il y en a autant de processus que de PCB, ces derniers sont donc des structures de données internes au système, qui sont stockées dans la zone protégée du système et sont rangés dans une table (table des processus) et organisées généralement en listes chainées. Les opérations nécessaires à la manipulation d’un processus (démarrer son exécution, l'arrêter, le mettre en attente d’E/S,...) sont traduites par des opérations sur

son PCB. Figure 3 : Table des processus

3. Ordonnancement de processus (Scheduling) : A chaque fois que le processeur devient inactif (libre), le système doit sélectionner un autre processus de la file d’attente des processus Prêts, et lui passe le contrôle du processeur. D’une manière plus concrète, cette tâche est prise en charge par deux routines système (deux sous-programmes) en l’occurrence : l’Ordonnanceur (Scheduler) et le Répartiteur (Dispatcher).

Un PCB comprend typiquement les champs suivants :

• un identificateur unique du processus (généralement un entier) ;

• Etat courant du processus: Nouveau, Prêt, Actif, Bloqué, Terminé.

• Valeur du compteur ordinal : Contient initialement l’adresse de la première instruction à exécuter du processus. Elle peut contenir également l’adresse de la prochaine instruction ou l’adresse de redémarrage en cas d’interruption du processus (voir chapitre 3 : Gestion des interruptions).

• Valeurs des Registres d’exécutions: Servent à la sauvegarde du contenu des registres du processeur au moment d’une interruption du processus (nécessaire pour la reprise correcte de l’exécution du processus).

Identificateur Etat du processus Compteur ordinal CO Registres d’exécutions Informations relatives à

la mémoire centrale Informations relatives

aux ressources Informations relatives à

l’UC

…..

…..

Figure 2 : Structure d’un PCB

• Informations relatives à la gestion de la mémoire: Définissent la zone mémoire occupée par le processus (adresse de début, la taille du processus,….). Ces informations servent à initialiser les registres utilisés par le mécanisme de protection mémoire, comme les registres Base et Limite par exemple (voir chapitre 4 : Gestion de la mémoire centrale).

• Informations comptables: Ce sont toutes les informations relatives à la consommation de ressources par le processus: nombre d’octets mémoire occupés, temps processeur consommé, nombre d’E/S effectuées, durée totale des E/S,...

• Informations relatives à la gestion de l’UC: Ces informations englobent la priorité d’exécution du processus, le temps maximum d’exécution autorisé et le temps estimé restant jusqu’à la fin de l’exécution.

3.1.Files d’attentes de Scheduling : Dans un système multiprogrammé les processus se trouvent dans des états différents, certains entre eux dans l’état ‘Prêt’, certains d’autres sont dans l’état ‘Bloqués' en attente de la fin d’une opération d’E/S, certains dans l’état ‘Terminé’ et enfin un seul processus qui se trouve dans l’état ‘Actif’ (en supposant qu’on dispose d’un seul processeur). La représentation la plus adéquate des états au niveau du système est faite sous la forme d’une liste chainée des PCBs (File d’attente) ; on pourrait citer trois types : la liste LISTE_PRETS, la liste LISTE_BLOQUES et la liste LISTE_TERMINES respectivement pour les processus Prêts, en Attente d’E/S et enfin pour ceux en phase de Terminaison. Avec cette représentation, le passage d‘un processus de l’état en ’Attente’ à l’état ‘Prêt’, par exemple, se traduira simplement par le transfert de son PCB de la liste LISTE_BLOQUES vers la liste LISTE_PRETS. Lorsqu’un nouveau processus arrive dans le système, ce dernier va lui créer un nouveau PCB, l’initialiser avec les paramètres correspondants et l’insérer dans LISTE_PRETS une fois que toutes les ressources demandées sont disponibles bien évidement (à l’exception du processeur).

L’état ‘Actif’ constitue un cas particulier ; comme il n’existe qu’un seul processus dans cet état, donc nous n’avons pas besoin d’une liste pour le représenter : un simple pointeur vers le PCB du processus Actif suffit. Ce dernier processus est souvent appelé Processus courant.

La liste LISTE_PRETS est en général triée selon la politique d’ordonnancement implémentée par le système (FCFS, SJF, etc.) de telle sorte que le processus en tête de liste soit le prochain processus à s’exécuter une fois que le processeur soit libre. Une fois démarrer l’exécution d’un processus, son PCB sera automatiquement supprimé de la LISTE_PRETS ainsi que la mise à jour du pointeur PROCESSUS_COURANT pour contenir l’adresse de ce PCB. La Figure 4 montre une implémentation possible de la LISTE_PRETS qui peut se faire au travers une liste chainée simple.

Figure 4 : Liste des processus Prêts

3.2. Modules système responsables à l’ordonnancement (les Ordonnanceurs) : Le cheminement d’un programme depuis son arrivée dans le système jusqu’au moment où il le

quitte permet de faire apparaitre plusieurs phases importantes dans le cycle de vie du processus.

La première phase est l’admission du programme dans le système. Elle a pour but de vérifier qu’il y ait suffisamment de ressources disponibles pour permettre l’exécution du programme. Une fois qu’un programme est admis dans le système (cela se traduit par la création d’un processus identifié par un PCB et son chargement en mémoire), il rentre donc en compétition pour avoir le contrôle du processeur (il devient donc un processus Prêt). Là encore, on aura plusieurs processus prêts dans le système et il faut faire des choix quant au prochain processus qui prendra le contrôle du processeur.

Au cours de son exécution, un processus peut, sous certaines conditions, être temporairement suspendu et son code sera déchargé de la mémoire au profit d’un autre processus. Cette situation peut se produire lorsque le système est surchargé, la mémoire est pleine et des processus prioritaires sont en attente sur disque. Le processus déchargé de la mémoire sera rechargé plus tard, lorsque la disponibilité de la mémoire le permettra afin de continuer son exécution. Dans ce cas également, le système devra adopter une politique de sélection des processus susceptibles d’être suspendus pour répondre aux questions suivantes : Quel(s) processus à décharger, Quel(s) processus à recharger, A quel moment décharger ou recharger un processus et sous quelles conditions ?

Dans les trois cas cités ci-dessus, on peut noter que nous avons affaire à un problème d'ordonnancement : c’est-à-dire, Dans quel ordre admettre les programmes ; Dans quel ordre exécuter les processus et Dans quel ordre les charger/décharger de la mémoire. Donc on peut définir trois niveaux d’ordonnancement et trois types d’ordonnanceurs dont les tâches sont bien évidemment complémentaires :

3.2.1. Ordonnanceur Long Terme : On l’appelle également Ordonnanceur de Programmes ; Son rôle est le contrôle de l’admission des programmes qui demandent l’exécution ; il les autorise pour qu’ils se chargent au niveau de la mémoire centrale. Il agit plutôt dans le long terme quand la mémoire se libère, ce qui arrive généralement en fin d’exécution de processus.

3.2.2. Ordonnanceur Court Terme : On l’appelle également Ordonnanceur de Processus.

Une fois qu’un un programme est admis par l’Ordonnanceur de Programmes, le processus correspondant est créé (il sera matérialisé par un PCB) et inséré dans LISTE_PRETS (en fait c’est son PCB qui sera inséré): le processus est à présent prêt à être exécuté car il possède toutes les ressources nécessaires à son exécution à

l’exception du processeur qu’il pourrait être occupé par l’exécution d’un autre processus. La fonction de l’Ordonnanceur de Processus est en fait de sélectionner le prochain processus à exécuter à partir de la LISTE_PRETS une fois que le processeur soit libre. Le processus choisi devient le processus Actif ; son PCB est supprimé de la LISTE_PRETS et le pointeur PROCESSUS_COURANT est mis à jour pour pointer vers le PCB du processus Actif. Le court terme de son action s’explique par le fait qu’il s’exécute à chaque fois que le processeur soit libre, ce qui arrive fréquemment.

3.2.3. Ordonnanceur Moyen Terme : Ce type d’ordonnanceur est utilisé pour décharger temporairement la mémoire centrale afin de permettre à d’autres programmes en attente à être chargés (généralement un programme de plus haute priorité). Un objectif important de l‘Ordonnanceur à Moyen Terme est de permettre à un plus grand nombre de programmes d’être admis dans le système et pour cela, il s’appuie sur une technique efficace dite de Swapping. Le Swapping consiste à décharger un processus de la mémoire vers un disque (opération dite de Swap-Out) et de le recharger en mémoire lorsque les ressources requises sont à nouveau disponibles (opération dite de Swap-In). La Figure 5 montre le fonctionnement de l’Ordonnanceur Moyen Terme.

Figure 5 : Ordonnancement à moyen terme

3.2.4. Le Dispatcheur de processus : l’exécution d’un processus Prêt passe par deux étapes complémentaires : la sélection du prochain processus à exécuter (à partir de la LISTE_PRETS), et la deuxième étape c’est pour démarrer réellement l’exécution du processus sélectionné. C’est cette deuxième étape qui est assurée par un module système appelé Répartiteur de processus (ou Dispatcher en anglais). Dans cette

étape, le démarrage de l’exécution d’un processus consiste à charger son contexte d’exécution (voir paragraphe 3.3.3) à partir de son PCB, et à lui donner le contrôle en initialisant le Pointeur d’Instructions (toujours à partir de son PCB) avec l’adresse de la première instruction à exécuter. Plus précisément, le rôle du dispatcher est :

1. initialiser le pointeur système PROCESSUS_COURANT avec l’adresse du PCB du processus sélectionné qui devient alors le processus Actif,

2. charger les registres Processeur à partir du PCB du processus Actif,

3. récupérer l’adresse de démarrage (ou redémarrage) du processus Actif à partir de son PCB,

4. basculer le mode d’exécution du processeur du mode Maître (mode d’exécution du Dispatcheur) vers le mode Esclave car on va exécuter un programme utilisateur (voir chapitre 3 : Gestion des interruptions).

5. charger le compteur ordinal avec l’adresse de démarrage du processus (cela démarrera automatiquement son exécution). Généralement, les étapes 4 et 5 sont exécutées en même temps en utilisant une seule instruction machine (c’est l’instruction LPSW, voir chapitre 3 : Gestion des interruptions).

Dans un contexte Multiprocesseur, en plus de son rôle classique, le Dispatcher joue un autre rôle qui est l’allocation d’un processeur (CPU) parmi ceux qui sont libres au profit du processus Actif et complète donc l’opération d’élection. La figure 6 représente le rôle de l’ordonnanceur et du répartiteur dans un système multiprocesseur.

Figure 6 : Rôle de l’Ordonnanceur et du Répartiteur 3.3. Politiques d’ordonnancement de processus :

Les politiques d’ordonnancement de processus permettent de définir l’ordre dans lequel les processus seront sélectionnées et exécutés par la suite selon un certain nombre de règles précises. Ces politiques possèdent des propriétés différentes et peuvent favoriser une

catégorie de processus plutôt qu’une autre. Pour choisir quelle politique utiliser dans une situation particulière, nous devons garder à l’esprit les propriétés de ces politiques.

Différents critères sont utilisés pour mesurer les performances des politiques d’ordonnancement.

3.3.1. Critères de performance : (maximiser ou minimiser ?) :

• Taux d’occupation du processeur (à maximiser) : C’est le rapport entre le temps d’exécution des processus par le processeur (temps effectif) sur le temps total écoulé.

• Capacité de traitement du processeur ou le Throughput ou bien le débit (à maximiser) : Il mesure le nombre de programmes exécutés par unité de temps (par exemple nombre de programmes exécutés par heure).

• Temps de traitement ou le Turnaround ou bien le temps de rotation (à minimiser) : C’est le temps s’écoulant entre la soumission du programme et sa terminaison = (temps terminaison - temps arrivée). Plus formellement, il s’exprime par : Temps passé d’attendre le chargement en mémoire + temps passé dans la file des prêts + temps d’exécution + temps d'attente E/S.

• Temps d’attente des processus ou le Waiting Time (à minimiser) : C’est le temps passé par un processus dans la file d’attente des processus prêts = Somme de tous les temps passés dans la file des prêts ;

• Temps de réponse des processus (à minimiser) : C’est le temps qui s'écoule entre l'entrée d'un processus et le moment où il commence à être exécuté pour la première fois, donc c’est le temps passé dans la file d’attente des processus prêts avant la première exécution (ou c’est le temps passé entre la création et le premier passage à l’état Actif). Ce critère est plus spécifiquement utilisé pour mesurer l’efficacité des systèmes interactifs en temps partage : il mesure le temps moyen entre la soumission d’une commande par un utilisateur et l’affichage des résultats sur écran. C’est en fait l’équivalent du temps de Turnaround pour les systèmes orientes batch.

3.3.2. Ordonnancement Préemptif et Non-Préemptif :

Le passage de l’état ‘Actif’ vers l’état ‘Prêt’ (voir Figure 1, Transition T4) correspond à une réquisition du processeur, c’est-à-dire que le processeur est retiré du processus ‘Actif’ alors que ce dernier a toujours besoin de l’exécution. Cette

réquisition porte le nom de Préemption. La notion de préemption recouvre la possibilité pour un processus ‘prêt’ d’interrompre le processus Actif au cours de son exécution. Les raisons de la préemption du processeur sont multiples : priorité d’exécution plus élevée pour le processus préempteur, temps processeur alloué écoulé (quantum), etc. Selon si l’opération de réquisition est autorisée ou non par le système, l’ordonnancement est qualifié d’ordonnancement préemptif ou non préemptif :

• si l’ordonnancement est non-préemptif, la transition de l’état ‘Actif’ vers l’état ‘Prêt’ est interdite : un processus quitte le processeur sauf s’il se termine ou s’il se bloque.

• si l’ordonnancement est préemptif, la transition de l’état ‘Actif’ vers l’état

‘Prêt’ est autorisée : donc un processus quitte le processeur soit lorsqu’il se termine, soit il se bloque ou si le processeur est réquisitionné.

3.3.3. Notion de contexte d’exécution : Rappelons que les informations nécessaires à l’exécution d’un processus (contenu des registres, adresse initiale d’exécution ou adresse de reprise, informations de protection mémoire, état de l’UC, etc.) sont toutes regroupées dans le PCB du processus. Ces informations font partie de ce que l’on appelle le contexte d’exécution du processus. Ce contexte est sauvegardé dans le PCB à chaque fois que le processus est interrompu. La reprise de l’exécution d’un processus est toujours précédée par le chargement de son contexte d’exécution qui consiste en l’initialisation des registres, l’initialisation de l’état de l’UC, le démasquage des interruptions et le chargement du Pointeur d’Instruction, et d’autres informations bien évidement (voir chapitre 3 : Gestion d’interruptions).

3.3.4. Notion de commutation de contexte d’exécution : La préemption s’accompagne de deux actions importantes : (a) l’arrêt de l’exécution du processus Actif et, (b) le démarrage du processus préempteur. Ces deux opérations nécessitent à leur tour de : (1) sauvegarder le contexte d’exécution du processus préempté dans son PCB, et (2) de charger le contexte d’exécution du processus préempteur à partir de son PCB. La combinaison de ces deux opérations successives de sauvegarde/chargement du contexte d’exécution est appelée commutation de contexte (voir chapitre 3).

3.3.5. Diagramme de Gantt : Le diagramme de Gantt est un outil utilisé en ordonnancement et en gestion de projets qui permet de visualiser dans le temps les diverses tâches composant un projet. Dans l’ordonnancement, il représente graphiquement l’évolution des processus au cours de leurs exécutions.

Exemple :

Processus Temps d’exécution

P1 24

P2 3

P3 3

Si les processus arrivent en même temps 0, dans l’ordre: P1, P2 et P3, Le diagramme de Gantt est :

Processus Temps de traitement Temps d’attente

P1 24 0

P2 27 24

P3 30 27

- Temps de traitement moyen : (24+27+30)/3 = 27

- Temps attente moyen : (0 + 24 + 27)/3 = 17

4. Algorithmes d’ordonnancement Non-préemptifs :

4.1.L’algorithme First Come First Served (FCFS): ou ce que l’on appelle PAPS : le Premier Arrivé le Premier Servi, C’est l’algorithme le plus simple. Son implémentation s’appuie sur l’utilisation d’une liste FIFO (First In First Out): le PCB d’un processus prêt est inséré à la fin de la LISTE_PRETS. A chaque fois que le processeur soit libre, il est alloué au processus dont le PCB se trouve en tête de la LISTE_PRETS. Le PCB du processus sélectionné est supprimé de la LISTE_PRETS pour devenir le processus Actif. La politique FCFS donne, en général, de très mauvais résultats en termes de performance, notamment un temps moyen de Turnaround élevé.

En prenant l’exemple précédent, avec le temps d’arrivée égal à 0 pour les trois programmes.

Donc leur exécution dans l’ordre P1-P2-P3 induit par la politique FCFS nous donne l’ordre d’exécution indiqué par le diagramme de Gantt suivant:

Un tel ordre d’exécution entraine un temps de Turnaround moyen égale à 27. Si l’on décide de changer l’ordre d’exécution de la sorte P2-P3-P1, le temps moyen de turnaround serait égal à 13. Dans le cas de la politique FCFS, on s’aperçoit donc que l’ordre d’exécution des

programmes peut influer de façon considérable sur les performances du système. Le choix d’exécuter les programmes dans l’ordre P2-P3-P1 dans le deuxième cas n’est pas fortuit:

nous avons fait en sorte que les programmes dont les temps demandés le plus courts s’exécutent d’abord. Ce qui a impliqué que les temps d’attente de ces programmes courts ont été fortement réduits, ce qui a eu pour effet d’améliorer le temps moyen de turnaround. On se rend ainsi compte, qu’un des problèmes de la politique FCFS vient du fait que les programmes avec des temps longs ont tendance à rallonger la file des processus en attente d’exécution (la LISTE_PRETS).

4.2.L’algorithme Shortest Job First (SJF): La politique implémentée dans cet algorithme a été introduite pour pallier au problème posé par la politique FCFS ; le SJF favorise les processus qui ont les temps processeur les plus courts. Son principe est comme suit: il associe à chaque processus la durée de son prochain temps-processeur. Quand le processeur se libère, il sera alloué au processus qui a le temps le plus court. Si deux ou plusieurs processus ont le même temps, ils sont simplement traités selon la politique FCFS.

Exemple :

Pour l’ensemble de programmes

Processus Temps d’exécution

P1 6

P2 3

P3 8

P4 7

On a le diagramme de Gantt suivant :

Le temps de Turnaround égal à 13.

4.3.Algorithme par Priorités non-préemptive : Une priorité définit l’urgence avec laquelle un processus doit être exécuté. Une priorité est un paramètre intrinsèque du processus et peut être déterminée de différentes façons :

1) à partir des caractéristiques propres du processus (heure d’arrivée, temps d‘exécution restant, espace mémoire occupé, etc.), ou d’une combinaison de celles-ci ;

2) explicitement définie et associée à un processus par le système ou même par l’utilisateur lui-même : dans ce cas, elle est représentée par un nombre compris dans un intervalle [0..n], 0 représentant la plus haute priorité.

Dans le cas d’un système non-préemptif, c’est-à-dire qu’une fois que le processeur est alloué à un processus, ce dernier s’exécutera jusqu’au moment où il quitte volontairement le processeur (attente d’E/S par exemple). Cela veut dire que, même si durant l’exécution d’un processus d’une priorité donnée, un autre processus de plus haute priorité ne pourra jamais interrompre le processus en cours d’exécution.

NB : Une priorité est dite interne quand elle est allouée par le système et externe autrement. Une priorité peut être fixe ou dynamique : elle est fixe quand on ne peut plus la modifier une fois allouée et dynamique si elle est modifiable durant la vie d’un processus.

5. Algorithmes d’ordonnancement Préemptifs :

5.1.L’algorithme Shortest Remaining Time First (SRTF) : L’idée directrice de cette politique est de favoriser les processus qui sont les plus proches de la fin de leur exécution de façon à libérer le processeur le plus rapidement possible et donner ainsi la possibilité à d’autres processus de s’exécuter. Son principe est comme suit : à chaque fois qu’un processus est inséré dans la LISTE_PRETS, le temps restant jusqu’à la fin de son exécution est comparé au temps restant du processus Actif ; dans le cas où le temps restant du nouveau processus est inférieur à celui du processus Actif, le système interrompra le processeur au profit du nouveau processus. Notons que la politique SRTF est la version préemptive de l’algorithme SJF.

Exemple : SRTF se base sur le temps d’exécution restant des processus, ce temps est simplement égal au temps d’exécution total du processus estimé au départ.

Processus Temps d’arrivée Temps demandé

P1 0 8

P2 1 4

P3 2 9

P4 3 5

Le diagramme de la Figure 7 représente l’application de la politique SRTF aux 4 programmes listés dans la table ci-dessus. La figure 7 prête des détails sur chaque événement qui survient :

Figure 7 : Exécution SRTF

Le processus P1 démarre son exécution au temps 0, avec 8 unités de temps. A l’arrivée de P2 au temps 1, l’ordonnanceur compare le temps restant de P1 (8-1=7 unités) au temps demandé par P2 (4 unités) et préempte (interrompe) P1 au profit de P2. P2 ne sera pas préempté à l’arrivée des processus P3 et P4 (aux temps 2 et 3) car leurs temps demandés respectifs sont plus élevés que celui de P2 dans les deux cas. On peut poursuivre ce raisonnement de proche en proche pour tous les processus et constater que P1 ne pourra reprendre son exécution qu’au temps 10 pour se terminer au temps 14. On s‘aperçoit aussi que les processus P1 et P3, avec les temps restants les plus élevés, ont été les plus pénalisés dans ce sens que leurs exécutions ont été différées jusqu’au la fin de l’exécution des autres processus. Ceci a entraîné un temps d’attente dans la liste des processus prêts très important pour ces deux processus. L‘évaluation du temps moyen de Turnaround donne le calcul suivant ((17-0)+(5-1)+(26-2)+(10-3))/4 = 13

Ce temps moyen assez élevé est essentiellement dû aux processus P1 et P3, car les temps de turnaround propres de P2 et P4 sont assez faibles. Car, la politique FCFS appliquée aux mêmes programmes, a donné un temps moyen de turnaround encore plus élevé comme le montre le calcul suivant : ((8-0)+(12-1)+(21-2)+(26-3)) / 4 = 15.25

5.2.L’algorithme Round-Robin (RR) ou Tourniquet ou bien Temps partagé : La politique RR se base sur l’idée d’une allocation du processeur de manière égale à tous les processus prêts, chacun a son tour, par petits laps de temps appelés quantum. La liste des processus prêts est traitée comme une liste circulaire. L’ordonnanceur de processus alloue à chacun des processus prêts, à tour de rôle, un quantum de temps au maximum. Un processus qui passe à l’état ‘prêt’ est toujours inséré à la fin de la liste. A chaque fois que le processeur est libre, l’ordonnanceur sélectionne le processus en tête de la liste s’il y en a un et lui alloue un quantum de temps (l’horloge qui décompte le temps est initialisée à ce moment-là avec la valeur correspondant à un quantum) et démarre son exécution via le dispatcher. Au cours de son exécution, le processus Actif peut :

(a) libérer le processeur volontairement suite à une demande d’une opération d’E/S ou suite à la fin de son exécution (normale ou anormale) ;

(b) libérer le processeur obligatoirement une fois consommer complétement son quantum. Dans ce cas, son exécution est arrêtée par l’interruption de l’horloge (voir chapitre 3, partie TD).

Exemple : On considère 3 processus à ordonnancer selon la politique RR. On suppose que les 3 processus sont tous présents dans la liste des prêts au temps 0. Le quantum est fixé à 4 unités de temps et les temps d’exécution demandés par chacun d’eux sont résumés dans le tableau suivant :

Le diagramme de Gantt suivant montre l’exécution de P1, P2, P3 et P4 selon la politique Round Robin:

Figure 8 : Diagramme de l’exécution Round Robin

5.3. Algorithme par Priorités préemptive : On remarquera que le même raisonnement s’applique aux politiques préemptives basées sur les priorités : si le processus qui arrive a une priorité supérieure à celle du processus Actif, le système appliquera la préemption au profit du nouvel arrivant. On peut remarquer également que SRTF est une politique basée par définition sur l’application d’une priorité qui est simplement en fonction de la valeur du temps d’exécution restant.

5.4.L’ordonnancement basé sur les listes multi-niveaux : toutes les politiques d’ordonnancement que nous avons vu jusqu’à présent sont toutes basées sur l’utilisation d’une seule liste des processus prêts à partir de laquelle on peut choisir le prochain processus à exécuter. Les listes multi-niveaux (en fait, c’est la liste des processus prêts qui est divisée en plusieurs sous-listes correspondant chacune à un niveau défini, voir figure 9) permettent une classification des processus selon leur nature avec la possibilité d’appliquer des politiques d’ordonnancements différentes et adaptées à chacune des classes de processus. Dans certains systèmes (dont Linux), l’ordonnancement des processus est base sur deux listes :

Processus Temps d’exécution

P1 17

P2 3

P3 4

P4 2

a) liste des processus d’avant-plan (foreground) qui sont les processus interactifs, requérant un temps de réponse court ;

b) liste des processus d’arrière-plan (background) qui sont simplement les processus à exécuter en batch, sans contrainte de temps spécifique.

Le principe de fonctionnement de cette politique est comme suit : la liste des processus prêts est divisée en plusieurs sous-listes séparées et indépendantes. Chaque sous-liste est traitée selon une politique d’ordonnancement différente. Les processus sont associés à une sous-liste donnée de façon permanente (c‘est-à-dire qu’une fois un processus inséré dans une sous-liste, il y restera attaché jusqu’à la fin de son exécution et y retournera à chaque fois qu’il redevient prêt). Cette association se fait sur la base de critères tels que la priorité, le temps d’exécution requis, etc. Une priorité fixe est également associée à chacune des sous-listes ; c’est cette priorité qui permet de définir différentes classes de processus.

L’ordonnancement entre les différentes sous-listes est préemptif. Cela implique :

(1) qu‘un processus dans une sous-liste donnée ne pourra s’exécuter que si toutes les sous-listes de plus haute priorité sont vides et,

(2) un processus arrivant dans une sous-liste vide de priorité plus haute que la sous-liste à laquelle appartient le processus Actif, entrainera toujours une préemption du processus Actif au profit du processus qui vient d’arriver.

En prenant comme exemple une liste à 3 niveaux (processus système, processus interactifs et processus batch), le fonctionnement général de cette politique peut être représenté à travers le schéma de la Figure 9.

Figure 9 : Ordonnancement multi-niveaux

Dans la figure 9, la sous-liste affectée aux processus du système est considérée comme la plus prioritaire, celle des processus batch la moins prioritaire. Tous les processus qui font une demande d’E/S rejoignent indistinctement la liste des processus en attente d’E/S. Un identificateur contenu dans le PCB permettra de savoir dans quelle sous-liste le processus devra s’exécuter quand il devient ou redevient prêt.

5.5.L’ordonnancement basé sur les listes multi-niveaux avec feedback : Dans un algorithme avec des files d’attente multi-niveaux simples, les processus sont assignés en permanence à une file d’attente dès qu’ils arrivent dans le système. Les processus ne se déplacent pas entre les files d’attente. Par contre, un algorithme avec des files d’attente feedback multi- niveaux permet aux processus de se déplacer entre les files d’attente. L’idée revient à séparer les processus en fonction de l’évolution de leurs caractéristiques dans le système.

Un exemple de cette politique est représenté sur le schéma de la Figure 10.

Figure 10 : Ordonnancement multi-niveau avec feed-back

La figure 10 montre trois sous-listes avec des priorités différentes sont définies. Les politiques d’ordonnancement sont Round Robin pour toutes les classes exceptée la classe de basse priorité (FCFS). De plus, la valeur du quantum va en augmentant de la classe la plus prioritaire à la classe la moins prioritaire (notant que la politique FCFS peut aussi être considérée comme une politique Round Robin avec quantum=∞).

Dans cet exemple, un processus de la file 3 pourra s’exécuter, si les files 1 et 2 soient vides. Un processus entrant dans la file 1 provoquera l’interruption d’un processus de la file 2. Le

quantum de temps de 8ms. Si au bout de ce temps, son cycle n’est pas terminé, il passe à la queue de la file juste inférieure. Si la file d’attente 1 est vides, on lui donne un quantum de temps de 16 ms. S’il ne se termine pas, il est interrompu et il est mis dans la file d’attente 3. Les processus de la file d’attente 3 sont exécutées seulement quand les files 1 et 2 sont vides.

Conclusion :

Ce chapitre a été consacré à la gestion du processeur qui représente une ressource très importante du système. Cette gestion peut s’exprimer comme un ordonnancement des processus en attente d’exécution. Le processus est devenu de ce fait un objet central du système auquel il faut allouer toutes les ressources nécessaires et notamment le processeur.

Son comportement est précisé à travers les états dans lesquels il peut se trouver et les opérations que le système est amené à lui appliquer. Le Process Control Block (PCB) caractérise, du point de vue du système, l’existence du processus et représente en quelque sorte sa carte d’identité. Dans le système, le processus est connu et manipulé uniquement à travers son PCB.

Enfin, nous avons introduit et expliqué les politiques d’ordonnancement de processus les plus importantes, non préemptives et préemptives, de la plus simple à la plus sophistiquée : FCFS, SJF, SRTF, Round Robin, Files multi-niveaux et Files multi-niveaux avec feedback. Des critères de performance comme le throughput, le temps de turnaround et le temps de réponse, ont été définis pour pouvoir évaluer l’efficacité d’une politique donnée et comparer les différentes politiques entre elles.

Résumé schématique du chapitre :