Université de Bretagne Occidentale Année universitaire Maîtrise d Informatique

Transcription

1 Université de Bretagne Occidentale Année universitaire Maîtrise d Informatique Module TER LES PROTOCOLES D'INVERSION DE PRIORITE Patrick Elard

2 Université de Bretagne Occidentale Année universitaire Maîtrise d Informatique Module TER PLAN 1. Introduction 2. Héritage des priorités 2.1 PIP: principe 2.2 Exemple 2.3 Caractéristiques 3. Protocoles à plafond de priorité 3.1 Priority Ceiling Protocol (PCP) Définitions Règles d'ordonnancement et d'allocation Exemple Temps de blocage Autres propriétés 3.2 Immediate Ceiling Priority Protocol (ICPP) 4. Stack resource 4.1 Stack Resource Policy (SRP): principe 4.2 Exemple 4.3 Caractéristiques 5. Conclusion

3 1. Introduction Le partage de ressources dans un système temps réel peut être à l'origine du phénomène dit d'inversion de priorité. Le but de l'étude est de comparer différents protocoles permettant de limiter les effets de ce problème, afin de déterminer leurs avantages et inconvénients, par l'analyse de leurs caractéristiques de fonctionnement et leur difficulté d'implémentation. Le cadre de l'étude porte sur le cas d'un ordonnancement monoprocesseur, préemptif de tâches périodiques, avec des ressources partagées. Rappelons qu'une tâche est une séquence d'instructions que l'on caractérise par une capacité C, une priorité P et une période T. La priorité d'une tâche peut être fixée par un des algorithmes d'ordonnancement de base que sont Rate Monotonic (RM) et Deadline Monotonic (DM) pour des priorités fixes, ou Earliest Deadline First (EDF) pour des priorités dynamiques. Une ressource est une structure logicielle pouvant être utilisée par une tâche pour avancer dans son exécution (ex: ensemble de variables, mémoire partagée, fichier etc.). Elle est dite privée lorsqu'elle est dédiée à une tâche en particulier, partagée si elle est utilisée par plusieurs tâches. Dans ce dernier cas, des sémaphores assurent l'accès exclusif. On définit une section comme étant une partie de code exécutée en exclusion mutuelle. Une tâche est dite bloquée si elle attend une ressource exclusive. Lorsqu'elle la prend, elle entre en section. Une ressource exclusive est dite libre si aucune tâche n'est dans une section utilisant cette ressource. Une inversion de priorité survient lorsqu'une tâche est bloquée par une tâche de priorité moindre. On ne peut alors plus prévoir le temps de blocage de la tâche de plus haute priorité, et les conséquences peuvent être graves. Soit l'exemple suivant: Considérons une ressource partagée entre tâches, et J 2 telles que P 0 > P 1 > P 2. J 2 t 0 t 1 t 2 t 3 t 4 t 5 t 6 - A l'instant t 0 : J 2 est activée, peut prendre et entre en section. - A l'instant t 1 : préempte J 2 et commence son exécution. - A l'instant t 2 : ne peut prendre car la ressource n'est pas libre. J 2 reprend son exécution. - A l'instant t 3 : est activée et préempte J 2. - A l'instant t 4 : J 2 ne peut prendre car la ressource n'est pas libre. J 2 reprend son exécution. - A l'instant t 5 : J 2 libère la ressource, préempte J 2 et entre en section en prenant la ressource. La durée du blocage dû à l'inversion de priorité est égale à t 5 -t 2 : elle peut être beaucoup plus importante que la durée de la section de J 2 car cette tâche peut être préemptée par d'autres tâches de priorité supérieure. - A l'instant t 6 : libère. Dans un système avec des ressources partagées, il est impossible d'éliminer toutes les inversions de priorités, mais il est possible d'en limiter les temps d'attente de façon à minimiser et prévoir les temps de blocages. Pour cela, il existe plusieurs approches. On peut empêcher la préemption lors de l'exécution de la Patrick Elard /06/05

4 section d'une tâche mais l'on crée ainsi des blocages inutiles, cette technique n'est donc envisageable que dans le cas où les sections s sont de courte durée d'exécution. On utilise plutôt des protocoles d'accès aux ressources où les conflits sont résolus en réalisant des ajustements sur les priorités des tâches. On en distingue trois types principaux: l'héritage des priorités avec le protocole PIP (Priority Inheritance Protocol), le plafond des priorités avec le protocole PCP (Priority Ceiling Protocol), et l'approche appelée "stack resource" avec le protocole SRP (Stack Resource Policy). Après avoir étudié chacun d'eux, nous comparerons leurs différentes caractéristiques pour en déterminer les avantages et les inconvénients. 2. Héritage des priorités Introduit par Sha, Rajkumar et Lehoczky en 1990 [3], le protocole PIP empêche des tâches de priorité moyenne de préempter la tâche responsable du blocage d'une tâche de haute priorité et de prolonger ainsi son temps de blocage, la situation remarquée dans l'exemple précédent est donc évitée. Le support d'ordonnancement est RM. Une version modifiée du protocole permet d'utiliser EDF pour avoir des priorités dynamiques (PIP for dynamic priorities)[2]. 2.1 PIP: principe L'idée de base de PIP est d'affecter temporairement la tâche responsable du blocage avec la priorité de la tâche la plus prioritaire. Chaque tâche J i possède une priorité fixe (déterminée par RM) ainsi qu'une priorité actuelle П i (t). Lorsqu'une tâche J i demande une ressource R k, on a l'une des situations suivantes [7]: 1) si R k est libre, J i prend la ressource et entre en section 2) si R k n'est pas libre, J i est bloquée. De plus, la tâche qui bloque J i hérite de sa priorité actuelle. Cette tâche continue à s'exécuter avec sa nouvelle priorité jusqu'à ce qu'elle libère la ressource. Elle reprend alors sa priorité initiale (c'est-à-dire celle qu'elle avait avant de prendre la ressource). L'héritage des priorités étant transitif, il se peut qu'une tâche hérite plusieurs fois si elle bloque plusieurs tâches. 2.2 Exemple Reprenons l'exemple précédent. L'ordonnancement devient le suivant: J 2 t 0 t 1 t 2 t 3 t 4 t 5 - A l'instant t 0 : J 2 est activée, peut prendre et entre en section. - A l'instant t 1 : préempte J 2 et commence son exécution. - A l'instant t 2 : ne peut prendre car la ressource n'est pas libre. J 2 reprend son exécution mais avec la priorité de. Patrick Elard /06/05

5 - A l'instant t 3 : est activée mais sa priorité est désormais inférieure à celle de J 2 qui continue son exécution. On voit ici que PIP introduit un nouveau type de blocage: le blocage d'héritage de priorité (inheritance blocking). - A l'instant t 4 : J 2 libère la ressource, reprend sa priorité initiale et est préemptée par. peut prendre la ressource libre et entre en section. - A l'instant t 5 : termine son exécution en libérant la ressource, peut commencer son exécution. 2.3 Caractéristiques On distingue deux types de blocage: le blocage direct (direct blocking) et le blocage d'héritage de priorité (priority inheritance blocking). Le blocage direct survient lorsqu'une tâche de haute priorité demande une ressource utilisée par une tâche de plus basse priorité. Le blocage d'héritage de priorité survient lorsqu'une tâche de priorité moyenne est bloquée par une tâche de plus basse priorité mais qui a hérité d'une priorité plus forte. PIP n'empêche pas les situations d'interblocage (deadlock), qui peuvent survenir lorsqu'il y a plusieurs ressources partagées: Considérons une tâche attendant une ressource puis une autre avant de libérer. Une autre tâche effectue l'allocation de ressource inverse, avec P 0 > P 1. t 0 t 1 t 2 t 3 - A l'instant t 0 : est activée, peut prendre et entre en section. - A l'instant t 1 : est activée et préempte. - A l'instant t 2 : peut prendre car cette ressource est libre. - A l'instant t 3 : ne peut pas prendre car cette ressource est utilisée par. De même ne peut pas prendre et on a une situation d'interblocage. De plus, PIP peut entraîner le phénomène de chaîne de blocage, qui survient lorsque la tâche la plus prioritaire est bloquée une fois par toutes les autres tâches. Considérons trois tâches,, J 2 avec P 0 > P 1 > P 2, ainsi que 2 ressources et. utilise puis, utilise et J 2 utilise. L'ordonnancement suivant illustre le phénomène de chaîne de blocage: J 2 t 0 t 1 t 2 t 3 t 4 t 5 t 6 Patrick Elard /06/05

6 - A l'instant t 0 : J 2 est activée, peut prendre et entre en section. - A l'instant t 1 : est activée et préempte J 2 car P 1 > P 2, ensuite peut prendre et entre en section. - A l'instant t 2 : est activée et préempte car P 0 > P 1. - A l'instant t 3 : ne peut pas prendre car cette ressource est utilisée par J 2 qui reprend son exécution avec la priorité de. - A l'instant t 4 : J 2 libère et reprend sa priorité initiale, préempte J 2 et entre en section en prenant la ressource. - A l'instant t 5 : libère mais ne peut prendre car cette ressource est utilisée par : reprend son exécution avec la priorité de. - A l'instant t 6 : libère et reprend sa priorité initiale, préempte et entre en section en prenant la ressource. La tâche, de plus forte priorité, a donc été bloquée une fois par toutes les autres tâches: au temps t 3 elle est bloquée par J 2 et au temps t 5 elle est bloquée par. Pour déterminer le temps de blocage B i, on considère les deux résultats suivants [3]: 1) s'il y a n tâches de basse priorité pouvant bloquer une tâche J i alors J i peut être bloquée pour une durée maximale de n sections s; 2) s'il y a m ressources distinctes qui peuvent bloquer une tâche J i alors J i peut être bloquée pour une durée maximale de m sections s. Le temps de blocage est alors égal à la durée de min{n, m} sections s. - Pour chaque tâche avec une priorité inférieure à P i on cherche l'ensemble des sections s pouvant bloquer J i, on fait la somme des durées maximales de la plus longue section de chacun de ces ensembles, - Pour chaque ressource, on cherche l'ensemble des sections s S k qui l'utilisent et peuvent bloquer J i, on fait la somme des durées maximales de la plus longue section de chacun de ces ensembles. Le temps de blocage est égal au minimum des deux durées trouvées. De façon plus formelle, on ordonne les indices des tâches selon leur priorité, de la plus forte à la plus faible. En notant П(R k ) la priorité maximum des tâches accédant à R k et D j,k la durée de la section associée, on a: n B i l = max{d j,k : П(R k ) P i } j=i+1 m B i s = max{d j,k : П(R k ) P i } k=1 k j<i B i = min{ B i l, B i s } Le test d'ordonnançabilité avec RM en l'absence de blocage est [2]: n (C i / T i ) n(2 1/n 1). i=1 En tenant compte du temps de blocage, on obtient alors: i Pour tout i n, (C k / T k ) + B i / T i i(2 1/i 1). k=1 Patrick Elard /06/05

7 Le temps de réponse se calcule à partir de l'équation récurrente suivante [2]: i-1 R i = C i + B i + R i / T j j=1 C j 3. Protocoles à plafond de priorité Définis par Sha, Rajkumar et Lehoczky en 1987, PCP et ICPP sont des améliorations de PIP permettant d'éviter les situations d'interblocage ainsi que les chaînes de blocage. Le support d'ordonnancement est RM. Une version modifiée du protocole permet d'utiliser EDF pour avoir des priorités dynamiques (DPCP: Dynamic Priority Ceiling Protocol) [5]. 3.1 Priority Ceiling Protocol (PCP) L'idée de base de PCP est d'étendre PIP avec des règles pour prendre les sémaphores, ces règles interdisant une tâche d'entrer en section s'il y a des sémaphores bloquées susceptibles de bloquer cette tâche. Ce protocole suppose que chaque tâche possède une priorité fixe et que les ressources utilisées sont connues avant le début de l'exécution Définitions On définit le plafond de priorité (priority ceiling) d'une ressource R i comme étant la plus haute priorité des tâches accédant à R i, et on la note П(R i ). Le plafond de priorité courant du système (current priority ceiling), noté П', est égal au maximum des plafonds de priorité des ressources utilisées, ou Ω si aucune ressource n'est utilisée (Ω est une priorité plus basse que n'importe qu'elle priorité) Règles d'ordonnancement et d'allocation Lorsqu'une tâche J i demande une ressource R j à un instant t, on considère les situations suivantes [7]: (a) R j est utilisée par une autre tâche. Dans ce cas la requête de J i est rejetée et J i est bloquée. (b) R j est libre. Deux cas: a. Si la priorité de J i est strictement supérieure au plafond de priorité courant П', alors J i peut prendre R j. b. Si P i П', J i ne peut prendre R j que si J i a pris la ressource dont le plafond de priorité est égal à П'. Dans le cas contraire, la requête de J i est rejetée et J i se retrouve bloquée. Lorsque J i se bloque, la tâche J j qui bloque J i hérite de la priorité actuelle P i de J i. Elle est alors exécutée avec cette priorité jusqu'à ce qu'elle libère toutes les ressources dont le plafond de priorité est supérieur à P i. Ensuite, sa priorité redevient celle qu'elle était Exemple Considérons 3 tâches, et J 2, avec P 0 > P 1 > P 2, ainsi que trois ressources partagées, et R 2 telles que [2]: - utilise puis - utilise R 2 - J 2 utilise R 2 puis On a donc: - П( )= P 0, - П( )= P 0, - П(R 2 )= P 1 Patrick Elard /06/05

8 R 2 J 2 R 2 R 2 R 2 P 0 P 2 P 1 P 2 t 0 t 1 t 2 t 3 t 4 t 5 t 6 t 7 t 8 t 9 - A l'instant t 0 : J 2 est activé, peut prendre R 2 car P 2 > П' = Ω. - A l'instant t 1 : préempte J 2 - A l'instant t 2 : ne peut prendre R 2 car P 1 n'est pas > П' = П(R 2 ). J 2 hérite de la priorité de et reprend son exécution. - A l'instant t 3 : J 2 peut prendre car aucune ressource n'est utilisée. - A l'instant t 4 : préempte J 2. - A l'instant t 5 : ne peut prendre car P 0 n'est pas > П' = П( ), J 2 hérite de la priorité de et reprend son exécution. - A l'instant t 6 : J 2 libère et reprend sa priorité P 2 = P 1. J 2 est alors préemptée par et prend car on a P 0 > П' = П(R 2 ). - A l'instant t 7 : termine son exécution, J 2 reprend la sienne et prend la ressource R 2. - A l'instant t 8 : J 2 libère R 2 et reprend sa priorité initiale P 2 : préempte J 2 et prend R 2 car on a P 1 > П' = Ω. - A l'instant t 9 : termine son exécution, J 2 peut reprendre et terminer la sienne Temps de blocage On distingue désormais trois cas de blocage: comme pour PIP on a le blocage direct (direct blocking) et le blocage d'héritage de priorité (priority inheritance blocking), on a en plus les situations de blocage de plafond de priorité (priority ceiling blocking) comme on peut le voir au temps t 5 dans l'exemple précédent. Avec PCP, le temps de blocage est réduit à la durée de la plus longue section parmi celles qui peuvent bloquer une tâche, car une tâche ne peut être bloquée que pour la durée d'une section. La difficulté est d'identifier l'ensemble des sections s susceptibles de bloquer une tâche. Pour une section exécutée par une tâche J j utilisant une ressource R k, on montre qu'elle peut bloquer une tâche J i si et seulement si P j < P i et П(R k ) P i. Le temps de blocage est donc: B i = durée de la plus grande section parmi celles des tâches de priorité P i et dont la ressource relative R i est telle que П(R i ) P i. De manière plus formelle, en notant D j,k la durée de la section de la tâche J j utilisant R k, on a : B i = max{d j,k : P j < P i et П(R k ) P i } j, k Autres propriétés Le protocole PCP permet d'empêcher les interblocages. La propriété de transitivité de l'héritage des priorités interdit en effet d'avoir un cycle de blocages [7]. Patrick Elard /06/05

9 Les chaînes de blocage sont également éliminées car une tâche ne peut être bloquée que par au plus une tâche de priorité inférieure [3]. S'appuyant sur RM, l'ordonnancement des tâches avec PCP est possible si le système vérifie le critère d'ordonnançabilité vu avec PIP: n (C i / T i ) n(2 1/n 1). i=1 3.2 Immediate Ceiling Priority Protocol (ICPP) Le principe de ICPP est identique à celui de PCP, sauf qu'ici une tâche a une priorité dynamique qui est le maximum de sa priorité fixe et des priorités plafond de toutes les ressources qu'elle occupe, c'est-à-dire que sa priorité augmente dès qu'elle prend une ressource [1]. Avec l'exemple précédent, on peut obtenir l'ordonnancement suivant: R 2 P 0 P 1 P 2 J 2 P 2 R 2 R 2 - A l'instant t 0 : J 2 est activé et commence son exécution. - A l'instant t 1 : J 2 peut prendre R 2 car P 2 > П' = Ω. J 2 entre en section avec P 2 = П 2 = P 1. - A l'instant t 2 : est activé, J 2 peut continuer à s'exécuter car P 2 = P 1. - A l'instant t 3 : J 2 peut prendre car P 2 П' et P 2 a pris la ressource R 2 (П' = П 2 ). P 2 continue son exécution avec P 2 = max{п 1, П 2 }= П 1 = P 0 - A l'instant t 4 : est activé, J 2 peut continuer à s'exécuter car P 2 = P 0. - A l'instant t 5 : J 2 libère et retrouve sa priorité P 2 = P 1. J 2 est alors préemptée par qui commence son exécution. - A l'instant t 6 : termine son exécution, ou J 2 peuvent reprendre la leur puisqu'elles ont la même priorité, ici par exemple reprend son exécution. - A l'instant t 7 : ne peut prendre R 2 car cette ressource est prise (par J 2 ), J 2 reprend donc son exécution. - A l'instant t 8 : J 2 libère R 2 et reprend sa priorité initiale P 2 : préempte J 2 et prend R 2 car on a P 1 > П' = Ω. - A l'instant t 9 : termine son exécution, J 2 peut reprendre et terminer la sienne. Par rapport à PCP, ce protocole modifie plus souvent les priorités puisque celles-ci changent même s'il n'y a pas de blocage. Mais il entraîne moins de commutations de contextes. 4. Stack resource t 0 t 1 t 2 t 3 t 4 t 5 t 6 t 7 t 8 t 9 L'important nombre de commutations de contextes induits par PCP a conduit à définir un nouveau protocole basé sur les piles de ressources [9]. Patrick Elard /06/05

10 SRP permet de limiter le nombre de changements de contextes entres les tâches en ne permettant la préemption d'une tâche par une autre que si on est sûr que les ressources utilisées par cette dernière seront disponibles. 4.1 Stack Resource Policy (SRP): principe L'idée de base de SRP est que les tâches sont bloquées au démarrage de leur exécution si on sait que les ressources qu'elles utilisent ne seront pas disponibles [7]. SRP introduit les notions de niveau de préemption (preemption level) et de plafond de préemption (preemption ceiling): - Chaque tâche J i possède un niveau de préemption fixe P' i, et une tâche J i ne peut préempter une tâche J j que si P' i > P' j. Contrairement à PIP et PCP, SRP peut être utilisé aussi bien avec RM qu'avec EDF [8]. Dans ce dernier cas, les niveaux de préemption doivent être ordonnés inversement par rapport aux dates d'échéance D i. - Chaque ressource R k possède un plafond de préemption П(R k ) qui est le maximum des niveaux de préemption des tâches pouvant bloquer sur R k. - Le système possède un plafond de préemption П' qui est le maximum des П(R k ). Les tâches prêtes à s'exécuter sont placées dans une pile par ordre décroissant de leur priorité. On effectue un test de préemption sur le sommet de la pile: pour qu'une tâche J i puisse préempter J j, il faut que sa priorité soit la plus forte parmi les tâches prêtes à s'exécuter, mais il faut également que son niveau de préemption soit supérieur au plafond de préemption du système. Si ce n'est pas le cas, on garde la tâche dans la pile et on effectue de nouveau le test à chaque fois que П' change de valeur. 4.2 Exemple Considérons 3 tâches, et J 2, avec P 0 > P 1 > P 2, ainsi que deux ressources partagées et telles que: - utilise puis - utilise puis - J 2 utilise On a donc: П( ) = P' 0 П( ) = P' 0 P' 0 < P' 1 < P' 2 On peut obtenir l'ordonnancement suivant [7]: J 2 t 0 t 1 t 2 t 3 t 4 t 5 t 6 - A l'instant t 0 : J 2 est activé, commence son exécution et peut prendre, le plafond de préemption du système devient П' = П( ) = P' 0. - A l'instant t 1 : est activé, mais P' 1 < P' 2 donc ne peut préempter J 2. - A l'instant t 2 : est activé, mais J 2 peut continuer à s'exécuter car P' 2 > P' 0. Patrick Elard /06/05

11 - A l'instant t 3 : J 2 libère et termine son exécution. et sont les tâches prêtes à s'exécuter. Comme P 0 > P 1 alors P 0 commence son exécution. - A l'instant t 4 : prend, on a alors П' = П( ) = P' 0. Le test de préemption sur n'est pas satisfaisant puisque P 1 < P 0, donc continue son exécution. - A l'instant t 5 : libère et prend, on a alors П' = П( ) = P' 0. Le test de préemption sur n'est pas satisfaisant puisque P 1 < P 0, donc continue son exécution. - A l'instant t 6 : termine son exécution, peut alors s'exécuter. 4.3 Caractéristiques Grâce au test de préemption, on est sûr que lorsqu'une tâche commence son exécution, elle ne sera pas bloquée sur une ressource. Les situations d'interblocage sont donc impossibles, et il en est de même pour les chaînes de blocage. Le calcul du temps de blocage est le même que pour PCP. Pour une tâche i il est égal à la durée de la plus longue section parmi les tâches pouvant la bloquer. La seule différence est que les tâches peuvent être bloquées uniquement au moment de la préemption, ce qui supprime les changements de contextes supplémentaires induits par PCP lors des blocages [7]. B i = max{d j,k : P' j < P' i et П(R k ) P' i } j, k Comme indiqué précédemment, le protocole SRP s'utilise aussi bien avec un ordonnanceur de type fixe (RM) que dynamique (EDF). Le critère d'ordonnançabilité avec RM est le même que pour PIP et PCP. Pour EDF, le système de tâches doit vérifier l'inéquation suivante [9]: i Pour tout i n, (C k / T k ) + B i / T i 1 k=1 5. Conclusion Les différents protocoles que nous avons étudiés permettent de limiter les effets des inversions de priorité dans l'ordonnancement de tâches périodiques sur un processeur. Nous avons vu que ces protocoles ont été définis pour répondre à des problèmes supplémentaires ou non résolus. Ainsi, les risques d'interblocage et de chaînes de blocages avec PIP ont été résolus par PCP. De même, le nombre important de changements de contexte entres les tâches avec PCP a conduit à définir le protocole SRP. Ce dernier, fonctionnant aussi bien avec un ordonnanceur à priorité fixe que dynamique, se distingue de plus par sa facilité d'implémentation [9], en partie due au fait que les blocages se font au niveau de la préemption et non au niveau de l'accès aux ressources. L'inconvénient de cette méthode est qu'une tâche qui n'utilise aucune ressource partagée peut se retrouver bloquée par le test de préemption. Lorsqu'une tâche préempte une autre, on est sûr que les ressources dont elle a besoin seront disponibles. Le tableau suivant présente les principaux résultats de l'étude: PIP PCP SRP Blocages Accès aux ressources Accès aux ressources Préemption Types de blocage Nombre de blocages Direct, héritage de priorité Direct, héritage de priorité, plafond de priorité Min{n, m} 1 1 Direct, Plafond de préemption Patrick Elard /06/05

12 Temps de blocage B i = min{ B l i, B s i } n B l i = max{d j,k : П(R k ) P i } k j=i+1 B s m i = max{d j,k : П(R k ) P i } j<i k=1 B i = max{d j, k j,k : P j < P i B i = max{d j, k j,k : P' j < P' i et П(R k ) P i } et П(R k ) P' i } Interblocage Oui Non Non Chaîne de blocage Oui Non Non RM RM RM EDF Pour tout i n, n (C k /T k ) + B i / T i i(2 1/i 1) k=1 idem RM: idem EDF: Pour tout i n, n (C k /T k ) + B i / T i 1 k=1 Priorité fixe fixe Fixe/dynamique Algorithme d'ordonnancement Ordonnançabilité Implémentation Dur Moyen Facile Distribué - Distributed PCP Multiprocessor PCP - L'étude des protocoles d'inversion de priorité s'est limitée aux systèmes monoprocesseur. Dans le cas distribué, il existe des protocoles adaptés à partir de PCP [2][6]. Le protocole MPCP (Multiprocessor PCP) est caractérisé par le fait que les sections s sont exécutées sur un processeur local en utilisant des sémaphores globaux. Il provoque des interblocages et des temps de blocages longs. Le principe du protocole DPCP (Distributed PCP) est que toutes les sections s associées à une même ressource sont gérées par un processeur spécifique et sont exécutées avec une priorité égale au plafond de priorité du sémaphore protégeant la ressource. Une tâche migre vers ce processeur pour exécuter sa section, en utilisant des appels de procédures distants. Les interblocages sont évités et les temps de blocages sont courts. Patrick Elard /06/05

13 Université de Bretagne Occidentale Année universitaire Maîtrise d Informatique Module TER BIBLIOGRAPHIE [1] C. André: Systèmes temps-réel, Université de Nice Sophia Antipolis (1999) [2] Chalmers: Parallel and Distributed Real-Time Systems (2001) [3] L. Sha, R. Rajkumar, J.P. Lehoczky: Priority Inheritance Protocols: An Approach to Real-Time Synchronization, IEEE transactions on computers, vol. 39, No. 9, pp (1990) [4] M. Alabu, T. Dechaize: Ordonnancement temps-réel local et réparti, Laboratoire Cedric, CNAM, Paris [5] M.I. Chen, K.J. Lin: Dynamic Priority Ceilings: A Concurrency Control Protocol for Real-Time Systems, The Journal of Real-Time Systems, 2, pp (1990) [6] N. Audsley, A. Burns: Real-Time system scheduling, Department of Computer Science, University of York, UK [7] S. Goddard: Resource Sharing, CSCE 990 Real-Time Systems [8] S. Ramamurthy: A lock-free approach to object sharing in real time systems, University of North Carolina, USA, 1997 [9] T.P. Baker: Stack-Based Scheduling of Realtime Processes, The Journal of Real-Time Systems, 3, pp (1991)