Évaluation de l’activité :
Activité 2.3: Ordonnancement de processus
E. Ordonnancement par priorité
Le principe consiste à associer au processus une priorité et choisir le processus donc, la priorité est la plus élevée.
Une priorité peut se définir en fonction de :
• L’espace mémoire utilisé ;
• L’importance relative au processus ;
• Ou l’instant du dernier accès au CPU.
L’algorithme d’ordonnancement avec priorité existe en version avec ou sans préemption.
Sans préemption
Processus Arrivée Durée Priorité
P1 0 5 7
P2 0 4 4
P3 3 3 2
P4 3 4 5
Tableau 6: Données des processus pour ordonnancement par priorité Avec préemption
Processus Arrivée Durée Priorité
P1 0 5 7
P2 0 3 5
P3 3 3 8
P4 3 4 5
Tableau 7: Données des processus pour ordonnancement avec préemption
Figure 11: Schéma d’ordonnancement sans préemption
Processus Temps d’attente Temps d’exécution
P1 0 5
P2 10 14
P3 11 14
P4 2 7
Moyenne 5,75 10
Tableau 8: Données des processus à ordonnancer sans préemption
Figure 12: Schéma d’ordonnancement avec préemption
Processus Temps d’attente Temps d’exécution
P1 0 8
P2 8 11
P3 0 3
P4 8 12
Moyenne 4 8
Tableau 9: Ordonnancement avec préemption Conclusion
Le partage du CPU entre les différents processus est une tâche qui doit être bien accomplie pour éviter que certains processus monopolisent cette ressource partagée. Pour cela, nous avons au cours de cette activité d’apprentissage vu les deux principales catégories d’ordonnancement : l’ordonnancement préemptif et l’ordonnancement non-préemptif. Des algorithmes d’ordonnancement ont été vus tant pour les systèmes de traitement par lots (exemple : algorithme du job le plus court en premier), que pour les systèmes interactifs (Round Robin, l’ordonnancement par priorité, ..).
Évaluation de l’activité :
Question 1 :
Considérez un système d’exploitation qui ordonnance les processus selon l’algorithme du tourniquet. La file des processus prêts contient des pointeurs vers les entrées de la table des processus (les descripteurs des processus).
Citez deux problèmes qui peuvent survenir si la file contient des éléments identiques (deux ou plusieurs pointeurs égaux).
Supposez que le système d’exploitation est composé de deux unités de contrôle (deux processeurs CPU1 et CPU2) et d’une unité d’E/S. Chaque processeur exécute l’algorithme du tourniquet avec un quantum de trois unités de temps (qt
= 3). Tous les processus prêts sont dans une même file d’attente. La commutation de contexte est supposée de durée nulle.
Considérez trois processus A, B et C décrits dans le tableau suivant :
Processus Instant d’arrivée Temps d’exécution
A 0 4 unités de CPU, 2 unités d’E/S, 2 unités de CPU
B 2 3 unités de CPU, 4 unités d’E/S, 2 unités de CPU
C 3.5 5 unités de CPU
La première ligne signifie que le processus A arrive dans le système à l’instant 0, son exécution nécessite dans l’ordre 4 unités de temps CPU, 2 unités de temps d’E/S et 2 unités de temps CPU. Au départ le processus A est élu par le processeur CPU1.
Si plusieurs événements surviennent en même temps, vous supposerez les priorités suivantes :
• Le CPU1 a la priorité d’accès à la file des processus prêts par rapport au CPU2.
• A la fin d’un quantum, le processus non terminé en cours est suspendu
uniquement si la file des processus prêts n’est pas vide. Le traitement réalisé à la fin d’un quantum est plus prioritaire que celui d’une fin d’E/S qui, à son tour, est plus prioritaire que l’arrivée de nouveaux processus dans le système.
1. Donnez les diagrammes de Gantt montrant l’allocation des deux processeurs, de l’unité d’E/S et l’évolution des états des files d’attente (celle des processus prêts et celle des processus en attente de l’unité d’E/S).
2. Calculez le temps moyen de virement (temps moyen de séjour).
Question 2 :
1) Expliquez la différence entre les Ordonnanceurs d’exécution non préemptifs (ex : ceux des premières versions de MacOS) et préemptifs (ex. ceux d’Unix, de Windows2000…).
2) Supposez que plusieurs processus sont à l’état prêt et que le processus élu exécute le programme suivant :
int main ( ) {
for ( int i=0; i<=100; i = min(100,i++)); return 0;
}
a)Que se passe-t-il pour les processus qui sont à l’état prêt, si l’Ordonnanceur d’exécution est non préemptif?
b)Que se passe-t-il pour les processus qui sont à l’état prêt, si l’Ordonnanceur d’exécution est préemptif?
3) A l’instant t, deux processus utilisateur P1 et P2 existent dans un système monoprocesseur. Le processus P1 est composé de deux threads. Le processus P2 est composé de trois threads. Les temps nécessaires à leurs exécutions sont résumés dans le tableau suivant :
Proc. Threads Temps d’exécution
P1 T11 T12 1 unité de CPU 3 unités de CPU
P2 T21 T22 T23 3 unités de CPU 2 unités de CPU 1 unité de CPU
Supposez que le processeur est libre. Donnez les diagrammes de Gantt montrant l’allocation du processeur, pour chacun des cas suivants :
a) Les threads sont supportés par le noyau (threads noyau). Le noyau ordonnance l’exécution des threads selon l’algorithme du tourniquet (Round Robin) avec un quantum de 2 unités.
La file d’attente des threads prêts, à l’instant t, est : →T23 T12 T22 T21 T11 → T11 est en tête de file.
b) Les threads sont implémentés entièrement au niveau utilisateur. Le noyau ordonnance l’exécution des processus selon l’algorithme du tourniquet avec un quantum de 2 unités. Les threads sont ordonnancés au niveau utilisateur selon l’algorithme du tourniquet avec un quantum de 1 unité.
Supposez que le processeur est libre et que les processus sont passés à l’état prêt dans l’ordre suivant :
P1 puis P2
Dans P1 : T11 puis T12
Dans P2 : T21 puis T22 puis T23
Dans tous les cas, le temps de commutation est supposé nul.
c) Calculez, pour chaque cas, le temps de virement (temps de séjour), relatif à l’instant t, de chaque processus. Comparez puis commentez les résultats.
Activité 2.4 : Interblocages
Introduction
Les ordinateurs disposent de nombreuses ressources (mémoire principale, disques, fichiers, périphériques, etc.) mais elles ne peuvent qu’à un seul processus à la fois. L’attribution de ces ressources à un processus revient au SE. Pour de nombreuses applications, les processus n’ont pas besoin d’un accès à une seule ressource mais doivent pouvoir accéder à plusieurs.
Supposons que les processus P1 et P2 désirent enregistrer chacun un document numérisé sur CD. Admettons que le processus P1 demande en premier lieu le scanner et que le
processus P2 demande l’accès au graveur CD. Ces deux premières demandent sont honorées.
Supposons maintenant que P1 sollicite le graveur et que la demande est refusée jusqu’à ce que P2 libère la ressource. Au lieu de libérer la ressource supposons que P2 sollicite à son tour le scanner. A ce stade, les deux processus sont bloqués et vont le rester indéfiniment. C’est ce que l’on appelle l’interblocage ou deadlock en anglais.Dans des situations complexes, les interblocages peuvent concerner plusieurs utilisateurs et plusieurs périphériques à la fois.
Notons que les interblocages ne concernent que les requêtes des périphériques d’E/S. Dans un système de gestion de base de données par exemple, un programme peut verrouiller plusieurs enregistrement qu’il utilise afin d’éviter qu’ils entrent en concurrence. Si un processus P1 verrouille l’enregistrement E1 et qu’un processus P2 verrouille l’enregistrement E2 et que l’un ou les deux tente(nt) de verrouiller un enregistrement déjà verrouillé par un autre, on est dans une situation d’interblocage. Les interblocages peuvent donc se produire tant sur les ressources matérielles que sur les ressources logicielles
Au cours de cette activité, nous allons examiner les situations d’interblocage, comment elles se présentent et comment les éviter. Même si nous sommes dans un contexte de SE, notons que les interblocages peuvent se produire dans des systèmes de base de données et dans d’autres contexte de traitement de données. Ce qui fait que le contenu développé s’applique à un large éventail de système multiprocesseurs.
Les ressources
L’exécution d’un processus nécessite un ensemble de ressources (mémoire principale, disques, fichiers, périphériques, etc.) qui lui sont attribuées par le système d’exploitation. L’utilisation d’une ressource se fait par l’intermédiaire des trois évènements suivants :
• La demande de la ressource: Si l’on ne peut pas satisfaire la demande celle-ci sera mise dans une table d’attente des ressources ;
• L’utilisation de la ressource : le processus demandeur utilise la ressource. A cet instant d’autres processus qui demandent la ressource doivent attendre ;
• La libération de la source : Le processus libère la ressource qu’il utilisait.
Par ressource, nous faisons référence à tout objet pouvant être alloué à un processus. Il peut s’agir d’un périphérique physique, d’une information (enregistrement verrouillé dans une base de données) bref tout ce qui peut être utilisé par un processus.
Les ressources peuvent être :
• réutilisables (existent après leur utilisation) : exemple les ressources physiques (imprimante, graveur, etc.) ou logiques (fichiers, mutex, verrous, etc.) ;
• d’usage partagé : c’est la ressource qui peut être utilisée par plusieurs processus en même temps ? Ce genre de ressources n’affecte pas les interblocages.
• préemptible ou non préemptible : La différence principale entre ressources préemptibles et non préemptibles est que les premières peuvent être retirées sans risque au processus qui les détient, tandis que les deuxièmes ne peuvent être retirées sans provoquer des problèmes. Comme exemples de ressources preémptibles nous avons le processeur (où le changement de contexte correspond à l’expropriation et l’état du processeur est copié à la Table de Contrôle de Processus (BCP)) et la mémoire virtuelle (le remplacement est une expropriation et le contenu de la page doit être copié au swap). Les imprimantes et les scanners sont des exemples de ressources non preémptibles.
Pour étudier le problème des interblocages, nous allons considérer uniquement les ressources non préemptibles.
Définition d’un interblocage
Des problèmes peuvent survenir, lorsque les processus obtiennent des accès exclusifs aux ressources. Par exemple, un processus P1 détient une ressource R1 et attend une autre ressource R2 qui est utilisée par un autre processus P2 et que le processus P2 attend à son tour le processus R1 qui est détenu par P1. Cette situation est un interblocage ou deadlock (en anglais).
De ce qui précède, nous constatons qu’un ensemble de processus est en interblocage si chaque processus attend la libération d’une ressource qui est allouée à un autre processus de l’ensemble. Comme tous les processus sont en attente, aucun ne pourra s’exécuter et donc libérer les ressources demandées par les autres. Par conséquent ces processus attendront indéfiniment.
Conditions d’un interblocage
Pour qu’une situation d’interblocage ait lieu, les quatre conditions suivantes doivent être remplies (Conditions de Coffman) :
• L’exclusion mutuelle : A un instant précis, une ressource est allouée à un seul processus ou est disponible.
• La détention et l’attente : Les processus qui détiennent des ressources peuvent en demander de nouvelles.
• Pas de préemption (réquisition) : Les ressources allouées à un processus sont libérées uniquement par le processus.
• L’attente circulaire : Il existe une chaîne d’au moins deux processus chacun attendant une ressource détenue par un autre processus de la chaîne.
La modélisation des interblocages
Les quatre conditions précédentes peuvent être modélisées à l’aide d’un graphe orienté (graphe d’allocation de ressources). Ce graphe est composé de deux types de nœuds et d’un ensemble d’arcs :
• Les processus qui sont représentés par des cercles.
• Les ressources qui sont représentées par des rectangles. Chaque rectangle contient autant de points qu’il y a d’exemplaires de la ressource représentée.
• Un arc orienté d’une ressource vers un processus signifie que la ressource est allouée au processus.
• Un arc orienté d’un processus vers une ressource signifie que le processus est bloqué en attente de la ressource.
Ce graphe indique pour chaque processus les ressources qu’il détient ainsi que celles qu’il demande.
Exemple :
Soient trois processus A, B et C qui utilisent trois ressources R, S et T comme illustré ci-dessous:
A B C
Demande de R Demande de S Demande de T Demande de S Demande de T Demande de R
Libère R Libère S Libère T
Libère S Libère T Libère R
Tableau 10: Tableau de synthèse des besoins de trois processus
Si ces trois processus sont exécutés de façon séquentielle : A suivi de B suivi C, il n’y pas d’interblocage. Par contre, supposons que l’exécution des processus est gérée par un ordonnanceur du type circulaire. Si les instructions sont exécutées dans l’ordre ci-dessous : 1. A demande R
2. B demande S 3. C demande T 4. A demande S 5. B demande T 6. C demande R
Cela constitue une situation d’interblocage.
On la schématiser comme suit :
Figure 13: Situation d’interblocage de trois processus
Un graphe réduit peut être utilisé pour déterminer s’il existe ou non un interblocage. Pour la réduction d’un graphe d’allocation des ressources, les flèches associées à chaque processus et à chaque ressource doivent être vérifiées.
• Si une ressource possède seulement des flèches qui sortent (il n’y a pas des requêtes), on les efface.
• Si un processus possède seulement des flèches qui pointent vers lui, on les efface.
• Si une ressource a des flèches qui sortent, mais pour chaque flèche de requête il y a une ressource disponible dans le bloc de ressources où la flèche pointe, il faut les effacer.
Exemple :
Soient 4 processus P1, P2, P3, P4 utilisant les ressources R1, R2, et R3. Le tableau ci-dessous montre l’allocation courante et le nombre maximaux d’unités de ressources nécessaires pour l’exécution des processus. Le nombre de ressources disponibles est A=[0,0,0].
Processus R1 R2 R3 R1 R2 R3
P1 3 0 0 0 0 0
P2 1 1 0 1 0 0
P3 0 2 0 1 0 1
P4 1 0 1 0 2 0
Tableau 11: Synthèse des besoins de 4 processus
Le graphe d’allocation de ressources correspondant est le suivant : Le graphe précédent peut être réduit comme suit :
P1 possède seulement des flèches qui pointent vers lui, alors on les efface.Les requêtes de R1 effectuées par P2 peuvent donc être allouées, et P2 aura seulement des flèches qui pointent vers lui. Alors on les efface aussi. On efface la flèche de R1 vers P3 (qui a changé de direction) car R1 n’a que des flèches sortantes. Ce qui nous donne le graphe final ci-dessous :
Traitement des interblocages
De ce qui précède, nous constatons que les situations d’interblocage peuvent se produire dans un système. Face à cette situation, que faut-il faire ?
1.Faire semblant que le problème n’existe pas
La première solution et c’est la plus simple consiste à appliquer la politique de l’autruche.
C’est-à-dire, ignorer complètement le problème et faire semblant qu’il n’existe pas. Cette stratégie est adoptée par la plus part des SE courants car le prix à payer pour les éviter est élevé.
2.La détection et la reprise des interblocages
Une autre solution consiste à détecter et reprendre les interblocages. C’est-à-dire qu’on les laisse se produire et on essaie d’y remédier à postériori.Pour détecter les interblocages, il construit dynamiquement le graphe d’allocation des ressources du système qui indique les attributions et les demandes de ressources. Dans le cas des ressources à exemplaire unique, il existe un interblocage si le graphe contient au moins un cycle. Dans le cas des ressources à exemplaires multiples, il existe un interblocage si le graphe contient au moins un cycle terminal (aucun arc ne permet de le quitter).
Le système vérifie s’il y a des interblocages :
• A chaque modification du graphe suite à une demande d’une ressource (coûteuse en termes de temps processeur).
• Périodiquement ou lorsque l’utilisation du processeur est inférieure à un certain seuil (la détection peut être tardive).
Ci-dessous, nous présentons un exemple d’un algorithme de détection des interblocages : Soient n le nombre de processus P[1], P[2],… , P[n] et m le nombre de type de ressources E[1], E[2],…, E[m] qui existent dans un système.
L’algorithme de détection des interblocages utilise les matrices et vecteurs suivants :
• Matrice C des allocations courantes d’ordre (n x m). L’élément C[i,j] désigne le nombre de ressources de type E[j] détenues par le processus P[i].
• Matrice R des demandes de ressources d’ordre n x m). L’élément R[i,j] est le nombre de ressources de type E[j] qui manquent au processus P[i] pour pouvoir poursuivre son exécution.
• Vecteur A d’ordre m. L’élément A[j] est le nombre de ressources de type E[j] &
_disponibles (non attribuées).
• Vecteur E d’ordre E d’ordre m. L’élément E[j] est le nombre total de ressources de type j existantes dans le système.
1. Rechercher un processus P[i] non marqué dont la rangée R[i] est inférieure à A.
2. Si le processus existe, ajouter la rangée C[i] à A, marquer le processus et revenir à 1
3. Si le processus n’existe pas, les processus non marqué son en interblocage.
L’algorithme se termine.
Exemple :
Considérons un système où nous avons trois processus en cours et qui dispose de 4 types de ressources : 4 dérouleurs de bandes, 2 scanners, 3 imprimantes et un lecteur de CD ROM.
Les ressources détenues et demandées par les processus sont indiquées par les matrices C et R.E=[4,2,3,1] ; A= [2,1,0,0]
C=[0 0 1 2 0 0 0 1 2 0 1 0 ] ; R=[2 0 0 1 0 1 2 1 0 1 0 0 ]
Seul le processus P3 peut obtenir les ressources dont il a besoin. Il s’exécute jusqu’à la fin puis libère ses ressources, ce qui donne : A=[2,2,2,0].
Ensuite P2 peut obtenir les ressources dont il a besoin. Il s’exécute jusqu’à la fin et libère ses ressources, ce qui donne : A=[4,2,2,1] . Enfin, P1 peut obtenir les ressources dont il a besoin. Il n’y a donc pas d’interblocage.
Lorsque le système détecte un interblocage, il doit le supprimer, ce qui se traduit généralement par la réalisation de l’une des opérations suivantes :
• Retirer temporairement une ressource à un processus pour l’attribuer à un autre.
• Restaurer un état antérieur (retour en arrière) et éviter de retomber dans la même situation.
• Supprimer un ou plusieurs processus.
L’évitement des interblocages
Dans ce cas, lorsqu’un processus demande une ressource, le système doit déterminer si l’attribution de la ressource est sûre. Si c’est le cas, il lui attribue la ressource. Sinon, la ressource n’est pas accordée. Un état est sûr si tous les processus peuvent terminer leur exécution (il existe une séquence d’allocations de ressources qui permet à tous les processus de se terminer).Un état est non sûr si on ne peut garantir que les processus pourraient terminer leurs exécutions.
Mais comment déterminer si un état est sûr ou non sûr ? Dijkstra a proposé en 1965 un algorithme d’ordonnancement, appelé l’Algorithme du banquier qui permet de répondre à
cette question. Cet algorithme, utilise les mêmes informations que celles de l’algorithme de détection précédent : matrices A, E, C et R. Un état est caractérisé par ces quatre tableaux.
Cet algorithme consiste à examiner chaque nouvelle requête pour voir si elle conduit à un état sûr. Si c’est le cas, la ressource est allouée, sinon la requête est mise en attente. L’algorithme détermine donc si un état est ou non sûr :
1. Trouver un processus Pi non marqué dont la rangée i de R est inférieure à A 2. Si un tel processus n’existe pas alors l’état est non sûr (il y a interblocage).
L’algorithme se termine.
3. Si tous les processus sont marqués alors l’état est sûr et l’algorithme se termine sinon aller à l’étape 1.
L’algorithme du banquier permet bien d’éviter les interblocages mais il est peu utilisé en pratique car on ne connaît pas toujours à l’avance les besoins en ressources des processus.
La prévention des interblocages
Pour prévenir les interblocages, on doit éliminer une des quatre conditions nécessaires à leur apparition.
• Pour éviter l’exclusion mutuelle, il est parfois possible de sérialiser les requêtes portant sur une ressource. Par exemple, pour les imprimantes, les processus « spoolent » leurs travaux dans un répertoire spécialisé et un démon d’impression les traitera, en série, l’un après l’autre.
• Pour ce qui concerne la deuxième condition (la détention et l’attente), elle pourrait être évitée si les processus demandaient leurs ressources à l’avance. Ceci est en fait très difficile à réaliser dans la pratique car l’allocation est, en général, dynamique. Empêcher cette condition serait donc particulièrement coûteux.
• La troisième condition (pas de préemption) n’est pas raisonnablement traitable pour la plupart des ressources sans dégrader profondément le fonctionnement du système. On peut cependant l’envisager pour certaines ressources dont le contexte peut être sauvegardé et restauré.
• Le problème de l’attente circulaire, dernière condition, peut être résolu en numérotant les ressources et en n’autorisant leur demande, par un processus, que lorsqu’elles correspondent à des numéros croissants ou en accordant aux processus une seule ressource à la fois (s’il a besoin d’une autre ressource, il doit libérer la première). Par exemple :
F(CD-ROM)=1 F(imprimante)=2 F(plotter)=3 F(rubban)=4
Ainsi on garantit qu’il n’aura pas de cycles dans le graphe des ressources. On peut exiger seulement qu’aucun processus ne demande une ressource dont le numéro est inférieur aux ressources déjà allouées. Mais ceci n’est pas non plus la panacée, car, en général, le nombre potentiel de ressources est si important qu’il est très difficile de trouver la bonne fonction F pour les numéroter.
Source :
http://www.groupes.polymtl.ca/inf2610/documentation/notes/chap7.pdf
D’autres détails se trouvent dans : Andrew Tanenbaum, Systèmes d’exploitation (2ème édition) page 169-195
Conclusion
L’interblocage est un problème lorsque des processus ont obtenu des accès exclusif à certaines ressources et lorsque chacun de ces processus sollicite une ressource détenu par un autre processus du groupe. Nous avons vu qu’il est possible d’éviter les interblocages en réalisant un suivi des états (un état sûr présente une séquence d’évènements qui offre la garantie que tous les processus peuvent se terminer et un état non sûr n’offre pas cette garantie. On a vu également que l’on peut éviter l’interblocage en concevant un système qui les empêche de se produire.
Évaluation de l’activité :
Question 1 :
1. Qu’est-ce qu’un interblocage ?
1. Qu’est-ce qu’un interblocage ?