Simulation et évaluation d algorithmes. Ordonnancement temps-réel. sous des contraintes de QoS

Transcription

1 LABORATOIRE D INFORMATIQUE DE NANTES-ATLANTIQUE Simulation et évaluation d algorithmes d ordonnancement temps-réel sous des contraintes de QoS Audrey MARCHAND et Maryline SILLY-CHETTO Laboratoire d Informatique de Nantes-Atlantique 2, rue de la Houssinière B.P NANTES CEDEX 3 Ordonnancement temps-réel RAPPORT DE RECHERCHE N o Septembre 2004 LINA, Université de Nantes 2, rue de la Houssinière BP NANTES CEDEX 3 Tél. : Fax. :

2 Audrey MARCHAND et Maryline SILLY-CHETTO Simulation et évaluation d algorithmes d ordonnancement temps-réel sous des contraintes de QoS 68 p. Les rapports de recherche du Laboratoire d Informatique de Nantes-Atlantique sont disponibles aux formats PostScript et PDF à l URL : Research reports from the Laboratoire d Informatique de Nantes-Atlantique are available in PostScript and PDF formats at the URL: Septembre 2004 by Audrey MARCHAND et Maryline SILLY-CHETTO

3 Simulation et évaluation d algorithmes d ordonnancement temps-réel sous des contraintes de QoS Audrey MARCHAND et Maryline SILLY-CHETTO Résumé La perspective traditionnelle de la théorie de l ordonnancement temps-réel s est largement reposée sur la communauté des systèmes temps-réel à contraintes strictes dans lesquels le manquement au respect de toutes les échéances des tâches (dites critiques) a souvent des conséquences catastrophiques sur le système contrôlé ainsi que sur son environnement. Cependant, cette perspective peut sembler parfois restrictive et peu adaptée pour un certain nombre d applications émergeantes pour lesquelles, la gestion des cas de surcharge réside dans le fait d écarter certaines instances de tâches de façon à améliorer l utilisation effective des ressources tout en minimisant la dégradation causée par le rejet de ces instances. Ce rapport s intéresse à la simulation et à l évaluation d algorithmes d ordonnancement temps-réel dynamiques sous des contraintes de Qualité de Service (QoS). Les travaux décrits concernent plus précisément l ordonnancement conjoint de tâches périodiques à pertes contraintes et de tâches apériodiques. L approche présentée vise à exploiter les pertes autorisées au niveau des tâches périodiques dans le but de minimiser le temps de réponse moyen aux requêtes apériodiques, par le biais de l utilisation du serveur de tâches apériodiques Earliest Deadline as Late as possible (EDL). Catégories et descripteurs de sujets : D.4.1 [Operating systems]: Process management Termes généraux : Algorithms, Management, Performance Mots-clés additionnels et phrases : systèmes temps-réel, ordonnancement, qualité de service, Earliest-deadline, tâches périodiques, serveur de tâches apériodiques

4

5 1 Introduction Un système temps-réel est un système dans lequel l exactitude d un calcul dépend non seulement du résultat logique (logical correctness) mais également de l instant auquel le résultat est produit (timeliness). Le système doit ainsi être capable de réagir suffisamment rapidement pour que la réaction ait un sens. Par conséquent, une application temps-réel implique généralement des tâches auxquelles sont associées des contraintes d échéances temporelles. A l heure actuelle, un nombre important de solutions ont été proposées pour ordonnancer des tâches temps-réel à contraintes strictes. Cependant, au cours des dernières années, des applications "nouvelles" ont émergé pour lesquelles il n est pas nécessaire de respecter toutes les échéances des tâches pourvu que les violations d échéances soient suffisamment espacées dans le temps. Ces applications émergeantes dans les domaines du multimedia et du contrôle automatique notamment, affichent des contraintes temps-réel firm. En d autres termes, les violations d échéances autorisées entraînent uniquement des dégradations de Qualité de Service (QoS) sans compromettre le bon fonctionnement du système et sans mettre en danger son intégrité. La performance du système est localement ou globalement dégradée tout en conservant ce dernier dans un état sécuritaire. Dans ce contexte, il semble important de définir les besoins en termes de QoS d un système, afin de délivrer un service à la hauteur des besoins décrits du point de vue de l utilisateur du système. Considérons par exemple un système d antiblocage des roues dans lequel typiquement, une tâche temps-réel détermine le début du freinage en scrutant périodiquement la vitesse de rotation échantillonnée de chaque roue. Dans un tel système, on se rend bien compte qu il n est pas nécessaire que toutes les instances de la tâche s exécutent dans le respect de leurs échéances. Cependant, il faut veiller à limiter le nombre d instances consécutives qui violent leurs échéances. Une situation similaire peut être rencontrée dans une application multimédia où le rejet de certaines instances de tâches de transmission de paquets de pixels par exemple, se traduira par une détérioration de l image au niveau du processus de reconstruction. Là encore, on s aperçoit de la nécessité de contrôler et d apposer des contraintes sur le nombre de paquets à transmettre (vis à vis d une période temporelle ou du nombre de requêtes de la tâche considérées). Les travaux concernant cette problématique ont été initiés par Hamdaoui et Ramanathan [5] par la définition d échéances (m,k)-firm, selon lesquelles chaque tâche périodique doit respecter au moins m échéances sur une fenêtre de k activations. Koren et Shaha [7] introduirent également la notion de facteur de pertes (skip factor) pour gérer des systèmes surchargés notamment. Si une tâche possède un paramètre de pertes s alors, elle écartera l exécution d une invocation parmi s invocations. Il s agit en fait d un cas particulier du modèle (m,k)-firm où m = k 1. Cette approche fournit une solution au problème de l ordonnancement de systèmes surchargés, tout en représentant une garantie de QoS pour les applications temps-réel. Caccamo et Buttazzo dans [2, 1] s appuyèrent sur ce modèle en ordonnançant des ensembles de tâches hybrides constituées de tâches périodiques tolérant d afficher des pertes et de tâches apériodiques à contraintes relatives. Ils proposèrent et analysèrent un algorithme, basé sur une variante de l algorithme d ordonnancement Earliest Deadline First (EDF), dans le but d exploiter les pertes des tâches périodiques en utilisant le serveur Total Bandwidth Server (TBS). La problématique décrite dans ce rapport est proche de cette dernière dans le sens où elle repose sur la minimisation du temps de réponse de tâches apériodiques à contraintes strictes ou relatives, en utilisant le serveur Earliest Deadline as Late as possible (EDL), sous des contraintes de pertes au sens Skip-Over. L approche tend à distribuer le temps CPU gagné du fait des pertes, de manière à améliorer le temps de réponse des requêtes apériodiques. 2 La Qualité de Service (QoS) en temps-réel 2.1 La notion de temps-réel firm La classification traditionnelle des systèmes temps-réel repose sur trois classes caractérisant les conditions temps-réel apposées sur ces systèmes. En effet, on distingue classiquement différents niveaux de contraintes temporelles : souple (soft) : la performance du système est dégradée sans engendrer des conséquences dramatiques si les contraintes temporelles ne sont pas rencontrées,

6 6 stricte (hard) : l incapacité du système à rencontrer les contraintes temporelles cause la faute du système et entraîne souvent des conséquences catastrophiques sur l environnement contrôlé, ferme (firm) : contrainte sévère mais où une faible probabilité de manquer les limites temporelles peut être tolérée. Les tâches temps-réel peuvent également être classées en plusieurs catégories de contraintes temporelles selon qu elles s appuient sur le respect d un des critères suivants : échéance (Deadline) : une tâche doit être achevée avant un instant donné dans le temps, durée d exécution nulle (Zero Execution Time) : la tâche doit être effectuée dans une période de temps égale à zéro dans le cas idéal, Qualité de Service (Quality Of Service) : la tâche doit effectuer une quantité fixée de service par unité de temps. Parmi les formes d expression de la QoS les plus courantes, on peut citer : la QoS déterministe : une valeur ou un intervalle de valeurs à respecter est défini, la QoS probabiliste : une probabilité P est établie. L inconvénient de ce niveau de service plus souple, réside dans le choix de probabilités adaptées, la QoS statistique : la contrainte est conforme à une certaine distribution stochastique. Pour une application ou un environnement parfaitement connu, la garantie déterministe est faisable. Dans d autres cas, il est impossible de prévoir et décrire le pire cas imaginable à cause de la dynamique du système et des perturbations aléatoires imprévisibles inhérentes à l environnement. L introduction du temps-réel "firm" envisage une définition plus fine des niveaux de QoS. Ainsi, une tâche ayant des contraintes temps-réel souples est dite firm si, considérant le fait qu une des instances de la tâche ne pourra être respectée, celle-ci est rejetée par le système. Cette politique permet ainsi de réduire la charge du système. Dans ce schéma, le traitement en retard des instances est alors considéré comme inutile. 2.2 Extension à la notion (m,k)-firm Hamdaoui et Ramanathan dans [5] introduisent cette notion d échéance (m,k)-firm. Selon leur définition, une source est soumise à une contrainte (m,k)-firm si au moins m parmi k instances consécutives doivent être exécutées dans le respect de leur échéance, avec m k. Le système est dit en échec dynamique si moins de m instances respectent leur échéance dans une fenêtre de k instances consécutives. On peut également remarquer que cette notion d échéances (m,k)-firm est une généralisation des échéances firm et soft. Aussi, une tâche à contraintes strictes peut-elle être représentée par une échéance (1,1)-firm. De même, une échéance (1,2)-firm établit la contrainte suivante : la tâche ne doit pas manquer 2 instances consécutives. 3 L ordonnancement de tâches périodiques sous contraintes de QoS 3.1 Description du modèle Skip-Over Dans ce modèle à pertes sporadiques, chaque tâche périodique T i est caractérisée par une durée d exécution dans le pire cas c i, une période p i, une échéance relative égale à sa période, et un paramètre de pertes s i, 2 s, qui fournit la tolérance de la tâche à manquer ses échéances. Selon la terminologie introduite par Koren et Shasha dans [7], chaque instance de tâche peut être rouge (red) ou bleue (blue). Une instance de tâche rouge doit être accomplie avant son échéance ; une instance de tâche bleue peut être abandonnée à tout moment. Le modèle répond à un certain nombre de règles élémentaires que nous énonçons ci-après : la distance entre 2 pertes consécutives doit être d au moins s périodes. si une instance de tâche bleue est abandonnée, les s i 1 prochaines instances de la tâche doivent être rouges. si une instance de tâche bleue s accomplit dans le respect de son échéance, la prochaine instance de la tâche reste bleue. les s i 1 premières instances de chaque tâche doivent être rouges. Ainsi, s 2 implique que, si une instance de tâche bleue a manqué son échéance alors, la prochaine occurrence de la même tâche doit être rouge. Lorsque s =, aucune perte n est autorisée. D une manière générale, en

7 7 autorisant les pertes, cela permet d ordonnancer des systèmes qui auraient été en surcharge autrement. A titre d illustration, nous pouvons considérer la figure 1 : : processing red instance : release time T 1 T 2 skip skip skip FIG. 1 Exemple de pertes sporadiques (s 1 = 3, s 2 = ) Le système est surchargé, mais les tâches peuvent être ordonnancées si T 1 perd une instance sur Conditions d ordonnançabilité Liu et Layland [8] ont montré qu un ensemble de n tâches périodiques (sans tolérance de pertes) est ordonnançable par EDF si et seulement si son facteur d utilisation du processeur est inférieur ou égal à 1 : 1 (1) Si l on considère maintenant le modèle Skip-over où l on tolère des pertes occasionnelles au niveau des tâches périodiques alors, le problème d ordonnançabilité de l ensemble des tâches est NP-difficile. Cependant, Koren et Shasha [7] ont montré que pour un ensemble Γ = {T i (p i, c i, s i )} de tâches périodiques autorisant des pertes, on obtient la condition nécessaire suivante pour l ordonnancement de Γ : n i=1 c i (s i 1) p i s i 1 (2) Dans ce cas, le facteur d utilisation du processeur n est plus calculé que sur la base des exécutions qui doivent avoir lieu. Une condition nécessaire et suffisante a été établie par Jeffay et Stone dans [6] énoncée par le théorème suivant : THEOREME 1 Un ensemble de tâches périodiques à contraintes strictes est ordonnançable par Earliest Deadline First (EDF) si et seulement si, pour tout intervalle L 0, L n L c i (3) p i i=1 Koren et Shasha se sont appuyés sur ces résultats pour prouver le théorème suivant relatif au modèle de tâches skip-over : THEOREME 2 Un ensemble de tâches périodiques à contraintes strictes tolérant des pertes sporadiques est ordonnançable si, pour tout intervalle L 0, L n i=1 D(i, [0, L]) où D(i, [0, L]) = ( L p i L p i s i )c i (4)

8 8 3.3 Les algorithmes d ordonnancement RTO (Red Tasks Only) Le premier algorithme est l algorithme Red Tasks Only (RTO). Cet algorithme rejette toujours les tâches bleues. Les tâches rouges sont ordonnancées suivant Earliest Deadline First (EDF). RTO "perd" des échéances selon un mode régulier, à savoir que la distance entre 2 pertes est exactement s périodes. Voici un exemple illustrant le fonctionnement de RTO (c i = 1, p i = 2, d i = 2, s i = 3) : : processing red instance : release time T i skip skip skip skip FIG. 2 Exemple de pertes sporadiques sous RTO BWP (Blue When Possible) Un autre algorithme plus flexible est l algorithme Blue When Possible (BWP) qui ordonnance des tâches bleues lorsque cela n empêche pas les tâches rouges de respecter leurs échéances. L algorithme évolue ainsi : ordonnancer les tâches rouges selon EDF. S il n y a aucune tâche rouge prête, alors activer une tâche bleue. S il y a plus d une tâche bleue prête alors en choisir une selon diverses heuristiques [7] : n importe laquelle, la tâche bleue dont l échéance est la plus éloignée, la tâche bleue dont l échéance est la plus proche, ajouter une tâche au hasard et regarder s il elle n introduit pas de surcharge, la tâche bleue ayant la propriété suivante : l échéance de la prochaine occurrence de sa tâche rouge associée est la plus proche. De même, illustrons l algorithme BWP sur un exemple (c i = 1, p i = 2, d i = 2, s i = 3) : : processing red instance : processing blue instance : release time T i skip skip skip FIG. 3 Exemple de pertes sporadiques sous BWP 4 L ordonnancement de tâches apériodiques avec le serveur EDL 4.1 Description du fonctionnement Le serveur Earliest Deadline as Late as possible (EDL) repose sur un algorithme d ordonnancement dynamique, capable d assurer la gestion de tâches apériodiques au sein d une application temps-réel. Il consiste à exécuter les

9 9 tâches périodiques au plus tôt lorsqu il n y a aucune activité apériodique. Dans le cas contraire, chaque fois qu une requête apériodique survient, toutes les tâches périodiques sont ordonnancées au plus tard, dans le respect de l ensemble des échéances des tâches. En d autres termes, l algorithme EDL tire profit de la laxité effective (c està-dire de l intervalle entre la date de fin d exécution et l échéance) des tâches périodiques, afin de minimiser le temps de réponse des apériodiques. Dans [3], Chetto et Chetto présentent une méthode simple pour déterminer la localisation et la durée des temps creux dans n importe quelle fenêtre d une séquence produite par EDL. La terminologie utilisée par les auteurs est la suivante : fy X représente la fonction de disponibilité définie vis à vis d un ensemble de tâche Y et d un algorithme d ordonnancement X, { fy X 1 si le processeur est inactif à t (t) = (5) 0 sinon Pour tous instants t 1 and t 2, l intégrale t t2 1 fy X (t)dt fournit le nombre total d unités de temps creux disponibles dans l intervalle de temps [t 1, t 2 ], désigné par Ω X Y (t 1, t 2 ). Il a été démontré [9] que le serveur EDL nécessite un calcul en-ligne des temps creux du processeur uniquement aux instants relatifs à l occurrence d une nouvelle tâche apériodique. La propriété fondamentale du serveur EDL est qu il garantit le maximum de temps creux dans un intervalle donné pour n importe quel ensemble de tâches. EDL a été démontré optimal [9]. THEOREME 3 Soit X un algorithme d ordonnancement préemptif quelconque. A tout instant t, Ω X T (0, t) Ω EDL T (0, t) (6) Un autre résultat significatif réside dans la complexité de l établissement de la séquence EDL. Le calcul enligne des temps creux [9] s effectue en O( R p n) où n désigne le nombre de tâches périodiques, R l échéance la plus éloignée parmi les tâches actives et p la plus petite période. 4.2 Détermination des temps creux en statique Le calcul de f EDL pour la localisation et la détermination de la durée des temps creux, repose sur deux vecteurs : le vecteur des échéances et le vecteur des temps creux. Le vecteur des échéances représente l ensemble des instants auxquels un temps creux est observable sur [0, P ], avec P = ppcm(p 1, p 2,..., p n ), l hyperpériode égale au plus petit commun multiple des périodes des tâches. Le vecteur des temps creux est utilisé pour consigner la durée des temps creux associés à ces différents instants Calcul du vecteur statique des échéances Considérons un ensemble de n tâches périodiques noté T = {T 1,..., T n } ordonnancées sur un système monoprocesseur. Chaque tâche T i = (c i, p i ) est caractérisée par une durée d exécution dans le pire cas c i et par une période p i. Le vecteur statique des échéances, noté K, représente l ensemble des instants considérés sur l hyperpériode [0, P ], précédant un temps creux. Il se construit à partir des échéances distinctes des tâches périodiques. En effet, le début de toute période de temps creux coïncide avec l échéance d une requête périodique [9]. avec k i < k i+1, k 0 = 0 et k q = P min {p i ; 1 i n} K = (k 0, k 1,..., k i, k i+1,..., k q ) (7) Calcul du vecteur statique des temps creux Ce vecteur traduit les longueurs des temps creux correspondant aux différents instants du vecteur des échéances. D = ( 0, 1,..., i, i+1,..., q ) (8)

10 10 où i représente la longueur du temps creux débutant au temps k i. D s obtient alors par la formule récurrente suivante : Illustration du calcul en statique de f EDL q = min {p i ; 1 i n} (9) i = sup (0, F i ), pour i = q 1 à 0 (10) n avec F i = (P k i ) P k q i c j k (11) p j j=1 k=i+1 Considérons l ensemble de tâches T = {T 1, T 2 } constitué de deux tâches périodiques T 1 (3, 10) et T 2 (3, 6). En appliquant les formules 9 et 10, on obtient le vecteur statique des échéances K = (0, 6, 10, 12, 18, 20, 24) et le vecteur statique des temps creux D = (3, 0, 0, 2, 0, 1, 0). Le calcul des intervalles de temps creux fournit la séquence EDL représentée sur la figure 4. : processing periodic task : processing idle time : release time T 1 T 2 f EDL k 0 k 1 k 2 k 3 k 4 k 5 k 6 FIG. 4 Calcul des temps creux en statique 4.3 Détermination des temps creux en dynamique On note τ le temps courant coïncidant avec l arrivée d une tâche apériodique Calcul du vecteur dynamique des échéances Le vecteur dynamique des échéances, noté K(τ), représente les instants supérieurs ou égaux à τ précédant un temps creux. Soit h l index tel que k h = sup {d; d K et d < τ} Calcul du vecteur dynamique des temps creux K(τ) = (τ, k h+1,..., k i,..., k q ) (12) Ce vecteur traduit les longueurs des temps creux associés aux instants du vecteur K. D(τ) = ( h (τ), h+1 (τ),..., i (τ),..., q (τ)) (13) avec h < i q représentant la longueur du temps creux débutant au temps k i. Chaque tâche périodique T j est caractérisée par ses paramètres statiques c j et p j, mais également par la quantité de processeur A j (τ) déjà allouée à son instance courante au temps τ, ainsi que par l échéance d j de sa requête courante au temps τ. On note M, la plus grande échéance parmi toutes les instances de tâches périodiques actives et l on figure dans le vecteur des temps creux l indice f tel que k f = min {k i ; k i > M}.

11 11 D(τ) est alors complètement défini par la relation de récurrence suivante : i (τ) = i, pour i = q à f (14) i (τ) = sup (0, F i (τ)), pour i = f 1 à h + 1 (15) n avec F i (τ) = (P k i ) P k n q i c j + k (τ) p j h (τ) = (P τ) n j=1 j=1 ( P τ p j Illustration du calcul en dynamique de f EDL c j A j (τ)) A j (τ) j=1 k=i+1 d j >k i q k=h+1 k (τ) (16) Nous pouvons à présent appliquer ces résultats à l ensemble T précédent. Cet ensemble de tâches périodiques est ordonnancé au plus tôt selon l algorithme EDF jusqu au temps τ = 5. On suppose qu une requête apériodique de durée 4 unités de temps survient au temps τ = 5, impliquant un calcul en-ligne des temps creux. Supposons que l on souhaite calculer le maximum de temps processeur libre dans l intervalle [5, 30] relativement à l ensemble T. A partir des formules 14, 15 et 16, on extrait le vecteur dynamique des échéances K(τ) = (5, 6, 10, 12, 18, 20, 24) ainsi que le vecteur dynamique des temps creux D(τ) = (3, 2, 0, 2, 0, 1, 0), comme l illustre la figure 5. : processing time : processing idle time : release time T 1 T 2 f EDL kτ k 1 k 2 k 3 k 4 k 5 k 6 FIG. 5 Calcul des temps creux en dynamique à l instant τ = 5 Dans cet exemple, les vecteurs dynamiques obtenus en exécutant les tâches périodiques au plus tard depuis l instant τ = 5, fournissent une réponse optimale vis à vis de la requête apériodique, à condition que celle-ci soit exécutée dans les temps creux de la séquence EDL établie à τ = 5. On peut observer sur la figure 6 que la requête apériodique reçoit bien 4 unités de temps (3 unités de temps dans le premier intervalle débutant à t = 5 et 1 unité de temps dans le second débutant à t = 12). 4.4 Cas de tâches apériodiques critiques Considérons à présent le problème de l acceptation de tâches apériodiques à contraintes strictes. On suppose que ces tâches sporadiques sont synchrones en ce sens que leur date d arrivée correspond avec leur date de réveil. Soit τ le temps courant coïncidant avec l arrivée d une requête sporadique R(τ, c, d), où c représente sa durée d exécution au pire cas et d son échéance. On suppose que le système peut présenter plusieurs tâches sporadiques à l état prêt au temps τ correspondant aux différentes requêtes précédemment acceptées. Par conséquent, celles-ci n ont pas terminé leur exécution à τ.

12 12 : processing time : release time T 1 T 2 EDL server FIG. 6 Exécution des apériodiques selon la séquence EDL calculée à τ = 5 On note R(τ) = {R i (c i (τ), d i ), i=1 à q(τ)} l ensemble des q tâches sporadiques présentes dans le système à τ. c i (τ) désigne la durée d exécution dynamique de R i (c est-à-dire sa durée d exécution restante) et d i son échéance. L ensemble R(τ) est ordonné tel que i < j implique d i d j. Dans [4], les auteurs proposent le test d acceptation optimal suivant pour des tâches apériodiques critiques gérées via le serveur EDL : THEOREME 4 R(τ, c, d) est acceptée si et seulement si pour toute tâche R i R(τ) {R} telle que d i d, on vérifie δ i (τ) 0, avec δ i (τ) défini comme suit : δ i (τ) = Ω EDL T (τ) (τ, d i) i c j (τ) (17) δ i (τ), appelée laxité de la tâche R i au temps τ, représente la longueur de l intervalle de temps qui sépare sa fin d exécution au plus tôt de son échéance. ΩT EDL (τ) (τ, d i) représente la somme totale des temps creux calculée entre τ et d i. La sommation i j=1 c j(τ) traduit la somme des exécutions restantes à l instant τ sur l ensemble des tâches sporadiques dont l échéance est inférieure ou égale à d i. 5 L ordonnancement de tâches apériodiques avec le serveur BG 5.1 Description du fonctionnement Le serveur de tâches apériodiques Background (BG) ordonnance les tâches apériodiques lorsqu il n y aucune activité périodique (c est-à-dire, lorsqu il n y a aucune tâche périodique à l état prêt) au sein du système. Le principal avantage de ce serveur réside dans sa simplicité de mise en oeuvre, en plus du fait qu il garantisse que les tâches apériodiques n affecteront pas le comportement des tâches périodiques. Par contre, l inconvénient majeur provient du fait que le temps de réponse aux requêtes apériodiques peut être très grand. j=1 Dans l exemple illlustratif de la figure 7, l ensemble T = {T 1 (10, 3), T 2 (6, 3)} est ordonnancé au plus tôt selon l algorithme Earliest Deadline First (EDF). Une requête apériodique R de durée 4 unités de temps, survient à l instant τ = 5. Le temps de réponse à la requête, via le service BG, s élève dans ce cas à 23 unités de temps. 5.2 Détermination des temps creux sous BG Le calcul de f EDS n est nécessaire que pour la gestion de l acceptation de tâches apériodiques critiques, où il est utile de connaître la séquence EDS, de manière à calculer la somme des temps creux sur un intervalle donné. Ceci n est pas le cas pour le serveur EDL dont le fonctionnement repose toujours sur le calcul des temps creux. La localisation et la détermination de la durée des temps creux sous BG repose sur deux vecteurs : le vecteur des

13 13 : processing time : release time T 1 T 2 BG server FIG. 7 Illustration du fonctionnement du serveur BG échéances et le vecteur des temps creux. Le vecteur des échéances représente l ensemble des instants auxquels se termine un temps creux sur [0, P ]. Le vecteur des temps creux est utilisé pour consigner la durée des temps creux précédant ces différents instants Calcul du vecteur des échéances Considérons un ensemble de n tâches périodiques noté T = {T 1,..., T n } ordonnancées sur un système monoprocesseur. Chaque tâche T i = (c i, p i ) est caractérisée par une durée d exécution dans le pire cas c i et par une période p i. Soit P = ppcm(p 1, p 2,..., p n ), l hyperpériode égale au plus petit commun multiple des périodes des tâches. Le vecteur statique des échéances, noté K, représente l ensemble des instants considérés sur l hyperpériode [0, P ], situés à la fin d un temps creux. Il se construit à partir des échéances distinctes des tâches périodiques. En effet, la fin de toute période de temps creux coïncide avec l échéance d une requête périodique [9]. avec k i < k i+1, k 0 = min {p i ; 1 i n} et k q = P Calcul du vecteur des temps creux K = (k 0, k 1,..., k i, k i+1,..., k q ) (18) Ce vecteur traduit les longueurs des temps creux qui précèdent les différents instants du vecteur des échéances. D = ( 0, 1,..., i, i+1,..., q ) (19) où i représente la longueur du temps creux qui précède le temps k i dans la séquence produite par EDS pour T sur [0, P ]. D s obtient alors par la formule récurrente suivante : i = sup (0, F i ), pour i = 1 à q (20) n avec F i = k i k q i c j k (21) p j j=1 k=i+1 Il est intéressant de remarquer que la séquence EDS en dynamique, est identique à celle calculée en statique puisque l activité apériodique n a aucune influence sur le comportement des tâches périodiques. Le calcul des temps creux sous BG via l établissement de la séquence EDS est par conséquent effectuée en O(N) où N représente le nombre total de requêtes distinctes sur [0, P ] Illustration du calcul de f EDS Considérons l ensemble de tâches T = {T 1, T 2 } constitué de deux tâches périodiques T 1 (3, 10) et T 2 (3, 6).

14 14 En appliquant la formule 20, on obtient le vecteur des échéances K = (6, 10, 12, 18, 20, 24, 30) et le vecteur des temps creux D = (0, 1, 0, 2, 0, 0, 3). Le calcul des intervalles de temps creux fournit la séquence EDS représentée sur la figure 8. A titre d exemple, la somme des temps creux sur l intervalle [12, 30], est égale à ΩT EDS (12)(12, 30) = 5. : processing periodic task : processing idle time : release time T 1 T 2 f EDS k 0 k 1 k 2 k 3 k 4 k 5 k 6 FIG. 8 Calcul des temps creux sous BG 5.3 Cas de tâches apériodiques critiques Considérons à présent le problème de l acceptation de tâches apériodiques à contraintes strictes. On suppose que ces tâches sporadiques sont synchrones en ce sens que leur date d arrivée correspond avec leur date de réveil. Soit τ le temps courant coïncidant avec l arrivée d une requête sporadique R(τ, c, d), où c représente sa durée d exécution au pire cas et d son échéance. On suppose que le système peut présenter plusieurs tâches sporadiques à l état prêt au temps τ correspondant aux différentes requêtes précédemment acceptées. Par conséquent, celles-ci n ont pas terminé leur exécution à τ. On note R(τ) = {R i (c i (τ), d i ), i=1 à q(τ)} l ensemble de tâches sporadiques présentes dans le système à τ. c i (τ) désigne la durée d exécution dynamique de R i (c est-à-dire sa durée d exécution restante) et d i son échéance. L ensemble R(τ) est ordonné tel que i < j implique d i d j. Dans [4], les auteurs proposent le test d acceptation optimal suivant pour des tâches apériodiques critiques, lorsque les tâches périodiques sont ordonnancées au plus tôt selon EDS : THEOREME 5 R(τ, c, d) est acceptée si et seulement si pour toute tâche R i R(τ) {R} telle que d i d, on vérifie δ i (τ) 0, avec δ i (τ) défini comme suit : δ i (τ) = Ω EDS T (τ) (τ, d i) i c j (τ) (22) δ i (τ), appelée laxité de la tâche R i au temps τ, représente la longueur de l intervalle de temps qui sépare sa fin d exécution au plus tôt de son échéance. ΩT EDS (τ) (τ, d i) représente la somme totale des temps creux calculée entre τ et d i. La sommation i j=1 c j(τ) traduit la somme des exécutions restantes à l instant τ sur l ensemble des tâches sporadiques dont l échéance est inférieure ou égale à d i. 6 Utilisation de EDL avec des tâches périodiques sous contraintes de QoS 6.1 EDL avec un modèle de tâches RTO Calcul du vecteur statique des échéances Soit l hyperpériode P = ppcm(s 1 p 1, s 2 p 2,..., s n p n ) définie sur un ensemble de tâches avec pertes. Le vecteur statique des échéances, noté K, représente l ensemble des instants considérés sur l hyperpériode [0, P ], précédant j=1

15 15 un temps creux. Il se construit à partir des échéances distinctes des instances périodiques rouges. La distance entre deux skips consécutifs est exactement de s i périodes dans lesquelles on observe m instances rouges suivies d une instance bleue avec m=(s i 1). Ces m instances rouges, considérées individuellement, sont donc périodiques de période s i.p i et leur échéance est égale à p i. Ainsi, pour chaque tâche T i, mp on observera sur [0, P ], s ip i échéances d instances rouges, 1 i n. Par conséquent, les instants k i du vecteur K = (k 0, k 1,..., k i, k i+1,..., k q ) sont définis comme suit : avec x = 0,..., ( P s ip i 1), et k = 1,..., m. et k i < k i+1, k 0 = min {p i ; 1 i n}, k q = P min {p i ; 1 i n} k i = (x.s i + k).p i (23) Preuve : Par définition du modèle RTO, chaque tâche T i de période p i et de paramètre de pertes s i, présente sur l intervalle [0, s ip i], (s i 1) requêtes d exécution d instances rouges suivies d une requête d exécution d instance bleue. Ainsi, les échéances sur requêtes rouges observées sur [0, s ip i] sont situées aux instants kp i avec 1 k (s i 1). Cette séquence de requêtes d exécution de (s i 1) instances rouges et d une instance bleue, est périodique de période s ip i. Par conséquent, pour chaque tâche T i, cette séquence RTO se répète fois sur [0, P ]. On en déduit alors que les échéances sur requêtes rouges sur [0, P ] sont situées aux instants xs ip i + kp i soit encore (xs i + k)p i, avec 1 k (s i 1) et 0 x 1. P s i p i P s i p i : processing red instance : processing blue instance : release time pi T i k 0 k 1 k m 1 kx k x+1 k 0 x+m 1 s ip i FIG. 9 Positionnement des instants k i(x, k) sous RTO Calcul du vecteur statique des temps creux Ce vecteur traduit les longueurs des temps creux correspondant aux différents instants du vecteur des échéances. D = ( 0, 1,..., i, i+1,..., q ) (24) où i représente la longueur du temps creux débutant au temps k i. D s obtient alors par la formule récurrente suivante, en tenant compte des pertes s j autorisées par chacune des tâches T j : q = min {p i ; 1 i n} (25) i = sup (0, F i ), pour i = q 1 à 0 (26) n avec F i = (P k i ) ( P k i P k q i )c j k (27) p j p j s j j=1 k=i+1

16 16 Preuve : Considérons pour chaque instant k i, 0 i q, la durée du temps creux qui lui est associée, notée i, pouvant être égale à zéro. Soit P = ppcm(s 1p 1,..., s ip i,..., s np n). Pour chaque tâche T i, la dernière instance observée sur [0, P ] est bleue. Par conséquent, puisque k q correspond à la dernière échéance rouge survenant sur [0, P ], q est donné par P k q aussi égal à min {p i; 1 i n}. Dans l intervalle [k i, P ], avec 0 i q, le nombre d échéances sur requêtes, rouges et bleues confondues, pour chaque tâche T j est égale à P k i p j. Si toutes ces requêtes ont terminé leur exécution sur [k i, P ], alors la durée totale du temps creux sur [k i, P ] est (P k i) n j=1 P k i p j c j. Dans le modèle RTO, chaque tâche T j tolère d écarter exactement une requête d exécution toutes les s j requêtes de la tâche. Les pertes totales par tâche sur [k i, P ] s élèvent alors à P k i p j s j c j. Ainsi, la durée totale du temps creux sur [k i, P ] en tenant compte des pertes est (P k i) n j=1 ( P k i P k i )c j. Comme la durée totale du temps creux sur [k i+1, P ] est donnée par p j p j s j q k=i+1 k, il vient que i = (P k i) n j=1 ( P k i p j Calcul du vecteur dynamique des échéances P k i p j s j )c j q k=i+1 k. Sinon, i = 0. Ce vecteur représente les instants supérieurs ou égaux à τ (le temps courant) précédant un temps creux. Soit h l index tel que k h = sup {d; d K et d < τ}. Comme dans le cas statique, tous les instants k i correspondent aux échéances distinctes des tâches rouges Calcul du vecteur dynamique des temps creux Ce vecteur traduit les longueurs des temps creux. K(τ) = (τ, k h+1,..., k i,..., k q ) (28) D(τ) = ( h (τ), h+1 (τ),..., i (τ),..., q (τ)) (29) avec h < i q représentant la longueur du temps creux débutant au temps k i. Par ailleurs, chaque tâche périodique T i est caractérisée par la quantité de processeur A i (τ) déjà allouée à son instance courante au temps τ. Cette instance possède également une échéance dynamique notée d i. On note M, la plus grande échéance parmi toutes les instances de tâches périodiques actives et l on figure dans le vecteur des temps creux l indice f tel que k f = min {k i ; k i > M}. D(τ) est alors complètement défini par la relation de récurrence suivante : i (τ) = i, pour i = q à f (30) i (τ) = sup (0, F i (τ)), pour i = f 1 à h + 1 (31) n avec F i (τ) = (P k i ) ( P k i P k n q i )c j + k (τ) p j p j s j h (τ) = (P τ) n j=1 j=1 ( P τ P τ )c j A j (τ)) p j p j.s j A j (τ) j=1 k=i+1 d j >k i q k=h+1 k (τ) (32) Preuve : Considérons l évaluation de la longueur du temps creux i(τ) suivant l instant k i, avec τ < k i k q, dans la séquence EDL établie en-ligne. Soit A j(τ) et d j respectivement la quantité de traitement effectuée sur la requête courante de T j et l échéance de cette requête. On définit alors M = sup {d j; T j T (τ)} comme la plus grande échéance parmi l ensemble T (τ) de toutes les instances de tâches actives à l instant τ. Etant donné que les tâches périodiques sont ordonnancées au plus tôt selon l algorithme EDF (Earliest Deadline First) jusqu à l instant τ, aucune requête apériodique possédant une échéance plus grande que M n a entamé son exécution à l instant τ. Par conséquent, la séquence EDL produite pour T (τ) sur [k f, P ], avec k f = min {k i; k i > M}, est identique à celle produite pour T hors-ligne. D où, i(τ) = i, pour i = q à f.

17 17 Si d j < k i, le temps total d exécution requis par la tâche T j sur [k i, P ], en tenant compte des pertes, est donné par ( P k i p j P k i p j s j )c j. Sinon, il est donné par ( P k i p j P k i p j s j )c j A j(τ) puisque la requête courante de T i a été partiellement exécutée. Par conséquent, la durée totale des temps creux sur [k i, P ] est donnée par (P k i) n j=1 ( P k i p j P k i p j s j )c j + n j=1 A j(τ). d j >k i En ce qui concerne la complexité algorithmique du calcul du vecteur des temps creux, on observe que la détermination des temps creux avec un modèle de tâches RTO est la même que celle observée avec un modèle de tâches classique, soit en O( R p n) où n désigne le nombre de tâches périodiques, R la plus grande échéance parmi les tâches actives et p la plus petite période Illustration du serveur EDL appliqué à un modèle de tâches RTO Considérons un ensemble T constitué de deux tâches périodiques T 1 (4, 10, 2) et T 2 (4, 6, 2). Ce système n est pas ordonnançable avec un ensemble de tâches périodiques définies selon le modèle classique, car le facteur d utilisation du processeur, n c i i=1 p i = dans ce cas, est strictement supérieur à 1. Par contre, le fait d autoriser des pertes au niveau des tâches nous permet d ordonnancer un système qui aurait été surchargé sans tolérance aux pertes. Ainsi, le facteur d utilisation des tâches en prenant en compte les pertes est de n c i(s i 1) i=1 p is i = , soit un facteur d utilisation du processeur inférieur à 1. On suppose à présent qu une requête apériodique de durée 5 unités de temps survient au temps τ = 12. Nous avons vu précédemment que les temps creux libérés grâce aux pertes introduites au niveau des tâches périodiques, pouvaient être exploitées pour exécuter des tâches supplémentaires et plus particulièrement pour ordonnancer des requêtes apériodiques. Ces tâches apériodiques sont alors exécutées au plus tôt, tandis que les activités périodiques sont reportées plus tard dans le temps, toujours dans le respect de leurs échéances. Les tâches dans cet exemple sont définies selon le modèle RTO. Le calcul hors-ligne des temps creux nous fournit le vecteur statique des échéances K = (0, 6, 10, 18) ainsi que le vecteur statique des temps creux D = (2, 0, 4, 4). La fonction f EDL associée à l ensemble de tâches T = {T 1, T 2 } est alors représentée sur la figure 10, illustrant la séquence EDL établie hors-ligne. : processing red instance : processing idle time : release time T 1 T 2 f EDL RT O k 0 k 1 k 2 k 3 FIG. 10 Séquence EDL-RTO établie au temps zéro A l arrivée de la requête apériodique au temps τ = 12, le calcul en-ligne des temps creux nous fournit le vecteur dynamique des échéances K(12) = (12, 18) et le vecteur dynamique des temps creux D(12) = (2, 4). La séquence effectivement exécutée est présentée figure 11. Le temps de réponse observé pour la tâche apériodique est de 9 unités de temps. Notons que ce temps de réponse est minimisé, à condition que la tâche apériodique soit exécutée dans les temps creux calculés par EDL à son arrivée. A partir de l instant t = 21, lorsqu il n y a plus de tâches apériodiques au sein du système, les tâches périodiques sont de nouveau ordonnancées au plus tôt selon l algorithme EDF.

18 18 : processing red instance : processing aperiodic request : release time T 1 T 2 EDL-RTO server kτ k 3 FIG. 11 Exécution de l apériodique selon la séquence EDL-RTO établie au temps zéro 6.2 EDL avec un modèle de tâches BWP Calcul du vecteur dynamique des échéances La différence ici vis à vis du modèle RTO, réside dans le fait qu à l instant t = τ, l ensemble des instances réveillées n est pas uniformément rouge. En effet, dans le modèle BWP, lorsqu il n y a aucune instance rouge à exécuter, l ordonnanceur tente d exécuter des instances bleues qui, par définition, peuvent être abandonnées à tout moment. De plus, si une instance bleue réussit, la prochaine instance de la tâche est encore bleue, introduisant un décalage par rapport à la séquence RTO d origine. Ce décalage dans le temps (move forward) à l instant τ est modélisé par un paramètre m i (τ) associé à la tâche T i, qui est incrémenté modulo s i, à chaque fois qu une instance bleue s accomplit dans le respect de son échéance. Par conséquent, les instants k i du vecteur K = (k 0, k 1,..., k i, k i+1,..., k q ) sont définis comme suit : avec x = 0,..., ( P s ip i 1), k = 1,..., m et 0 m i (τ) m. Remarque : pour x = ( P 1), les instants k s i.p i sont calculés modulo P. i k i = (x.s i + k + m i (τ)).p i (33) Preuve : Sans décalage au niveau de la séquence RTO, les échéances sur requêtes rouges observées sur [0, s ip i] sont situées aux instants kp i, avec 1 k (s i 1). Soit m i(τ) le décalage dans le temps à l instant τ associé à la tâche T i, avec 0 m i(τ) (s i 1). Chaque décalage dans la séquence des instances repousse les échéances de l ensemble des requêtes dans le temps d une quantité p i. Ainsi, les échéances sur requêtes rouges sur [0, s ip i] sont redéfinies aux instants kp i + m i(τ)p i. Par conséquent, si l on considère les et consécutives sur [0, P ], on obtient k i = (x.s i + k + m i(τ)).p i avec 0 x ( P s i.p i 0 m i(τ) (s i 1). P s i p i séquences RTO identiques 1), 1 k (s i 1) et Calcul du vecteur dynamique des temps creux Ce vecteur traduit les longueurs des temps creux. D(τ) = ( h (τ), h+1 (τ),..., i (τ),..., q (τ)) (34) avec h < i q représentant la longueur du temps creux débutant au temps k i. Par ailleurs, chaque tâche périodique T i est caractérisée par la quantité de processeur A i (τ) déjà allouée à son instance courante au temps τ. Cette instance possède également une échéance dynamique notée d i. On note M, la plus grande échéance parmi toutes les instances de tâches périodiques actives et l on figure dans le vecteur des temps creux l indice f tel que k f = min {k i ; k i > M}.

19 19 D(τ) est alors complètement défini par la relation de récurrence suivante : i (τ) = sup (0, F i (τ)), pour i = q à τ (35) n avec F i (τ) = (P k i ) ( P k i P k i + m j (τ)p j + m j(τ)p j )c j (36) p j p j s j p j s j + n j=1,d j >k i bleue reussie/rouge A j (τ) j=1 q k=i+1 k (τ) Preuve : La séquence BWP observée sur [k i, P ] est identique à la séquence RTO observée sur [k i m j(τ)p j, P m j(τ)p j], où l on tient compte du décalage m j(τ), 0 m j(τ) (s i 1), associée à la tâche T j. L évaluation des pertes sur cet intervalle correspond au nombre d instances bleues présentes dans la séquence RTO considérée sur [k i m j(τ)p j, P m j(τ)p j]. Cette quantité est égale au nombre de pertes observées sur l intervalle P (k i m j(τ)p j) auquel on soustrait le nombre de pertes observées sur l intervalle P (P m j(τ)p j). Les pertes totales par tâche sur [k i, P ] s élèvent alors à P (k i m j (τ)p j ) p j s j c j P (P m j (τ)p j ) c j, soit après simplifications ( P k i+m j (τ)p j p j s j m j (τ)p j p j s j )c j. Si d j < k i, le temps total d exécution requis par la tâche T j sur [k i, P ], en tenant compte des pertes, est donné par ( P k i p j P k i+m j (τ)p j p j s j + m j (τ)p j p j s j )c j. Sinon, il est donné par ( P k i p j p j s j P k i+m j (τ)p j p j s j + m j p j (τ) p j s j )c j A j(τ) puisque la requête courante de T i a été partiellement exécutée. La sommation des A j(τ) s effectue sur les instances rouges qui ont entamé ou terminé leur exécution à l instant τ, et uniquement sur les instances bleues qui ont terminé leur exécution à l instant τ. En effet, étant donné que ces instances bleues ont réussi leur exécution, les instances suivantes seront également bleues. Ainsi, ces instances bleues décalées à τ + p i sont considérées comme des instances rouges dans la séquence EDL simulée sur la base RTO à l instant τ. Par conséquent, la durée totale des temps creux sur [k i, P ] est donnée par : (P k i) n j=1 ( P k i p j P k i+m j (τ)p j p j s j + m j (τ)p j p j s j )c j + n j=1,d j >k i bleue reussie/rouge Illustration du serveur EDL appliqué à un modèle de tâches BWP A j(τ). Considérons à présent le même ensemble de tâches hybrides que celui utilisé précédemment pour illustrer le serveur EDL avec un modèle de tâches RTO (cf. section 6.1.5). Les temps creux sont calculés en-ligne selon le type des tâches périodiques actives, comme le montre la figure 12. : processing red instance : processing blue instance : processing idle time : release time T 1 T 2 f EDL BW P kτ k 2 FIG. 12 Séquence EDL-BWP établie à τ = 12 Dans le modèle BWP, on peut observer que la séquence produite pour T 1 est la même que celle établie dans le cas RTO alors que celle produite pour T 2 est décalée d une période du fait de l exécution réussie de l instance

20 20 bleue de T 2 au temps t = 12. Ainsi, les temps creux calculés en-ligne selon le modèle BWP sont représentés dans les deux vecteurs K(12) = (12, 24) et D(12) = (8, 2). L exécution de la requête apériodique dans les temps creux ainsi calculés est illustrée sur la figure 13. Les instances bleues de T 1 et T 2 respectivement réveillées aux temps t = 10 et t = 12, sont abandonnées au terme de leurs échéances. En effet, la requête apériodique s exécute pendant 5 unités de temps à partir de τ = 12 selon la séquence EDL établie par le calcul des vecteurs K(τ) et D(τ). Dans cette séquence EDL, les instances bleues, qui par définition peuvent être abandonnées à tout moment, représentent toujours de potentiels temps creux pouvant être exploiter dans le but de minimiser le temps de réponse aux requêtes apériodiques. A partir de l instant t = 17, lorsqu il n y a plus de tâches apériodiques au sein du système, les tâches périodiques sont de nouveau ordonnancées au plus tôt selon l algorithme EDF. On peut noter que les violations d échéances bleues survenant aux temps t = 18 et t = 20, impliquent obligatoirement des instances de type rouge pour les s i 1 instances suivantes, de manière à respecter les contraintes de QoS au niveau des tâches. : processing red instance : processing blue instance : processing aperiodic request : release time T 1 T 2 EDL-BWP server aborted 0 10 aborted kτ k 2 FIG. 13 Exécution de l apériodique selon la séquence EDL-BWP calculée à τ = Cas de tâches apériodiques critiques Considérons à présent le problème de l acceptation de tâches apériodiques à contraintes strictes dans un système comportant des tâches périodiques à pertes contraintes définies selon le modèle RTO ou BWP. On se place sous les mêmes conditions que pour l étude de l acceptation de tâches apériodiques critiques dans un système sans pertes (cf. section 4.4) Test d acceptation sous EDL avec un modèle RTO Le test d acceptation dans le cas de tâches avec pertes sous RTO s appuie sur celui énoncé précédemment (cf. Théorème 17) dans le cas de tâches sans pertes. THEOREME 6 R(τ, c, d) est acceptée si et seulement si pour toute tâche R i R(τ) {R} telle que d i d, on vérifie δ i (τ) 0, avec δ i (τ) défini comme suit : δ i (τ) = Ω EDL RT O T (τ) (τ, d i ) i c j (τ) (37) Dans ce cas, seule la somme des temps creux Ω EDL RT O T (τ) (τ, d i ) calculée entre τ et d i, diffère vis à vis du test d acceptation sous un modèle de tâches classique sans pertes. j=1

21 Test d acceptation sous EDL avec un modèle BWP De même, on obtient le test d acceptation suivant dans le cas d un modèle de tâches périodiques BWP : THEOREME 7 R(τ, c, d) est acceptée si et seulement si pour toute tâche R i R(τ) {R} telle que d i d, on vérifie δ i (τ) 0, avec δ i (τ) défini comme suit : δ i (τ) = Ω EDL BW P T (τ) (τ, d i ) i c j (τ) (38) 7 Utilisation de BG avec des tâches périodiques sous contraintes de QoS 7.1 BG avec un modèle de tâches RTO Illustration du serveur BG appliqué à un modèle de tâches RTO Le serveur de tâches apériodiques Background (BG) ordonnance les tâches apériodiques lorsqu il n y aucune activité périodique (c est-à-dire, lorsqu il n y a aucune tâche périodique à l état prêt) au sein du système. Dans le cas de tâches périodiques basées sur le modèle RTO, le serveur BG ordonnance les tâches apériodiques lorsqu il n y a aucune tâche rouge active dans le système. Considérons un ensemble T constitué de deux tâches périodiques T 1 (4, 10, 2) et T 2 (4, 6, 2). Ce système n est pas ordonnançable avec un ensemble de tâches périodiques définies selon le modèle classique, car le facteur d utilisation du processeur, n c i i=1 p i = dans ce cas, est strictement supérieur à 1. Par contre, le fait d autoriser des pertes au niveau des tâches nous permet d ordonnancer un système qui aurait été surchargé sans tolérance aux pertes. Ainsi, le facteur d utilisation des tâches en prenant en compte les pertes est de n c i(s i 1) i=1 p is i = , soit un facteur d utilisation du processeur inférieur à 1. On suppose à présent qu une requête apériodique de durée 5 unités de temps survient au temps τ = 12. Nous avons vu précédemment que les temps creux libérés grâce aux pertes introduites au niveau des tâches périodiques, pouvaient être exploitées pour exécuter des tâches supplémentaires et plus particulièrement pour ordonnancer des requêtes apériodiques. Les tâches dans cet exemple (cf. figure 14) sont définies selon le modèle RTO et sont toujours ordonnancées au plus tôt selon l agorithme EDF. Le temps de réponse observée pour la tâche apériodique est de 17 unités de temps. j=1 : processing red instance : processing aperiodic request : release time T 1 T 2 BG-RTO server FIG. 14 Exécution des apériodiques selon BG-RTO Détermination des temps creux sous BG avec un modèle RTO Le calcul de f EDS RT O n est nécessaire que pour la gestion de l acceptation de tâches apériodiques critiques, où il est utile de connaître la séquence EDS-RTO, de manière à calculer la somme des temps creux sur un intervalle donné. Ceci n est pas le cas pour le serveur EDL dont le fonctionnement repose toujours sur le calcul des temps temps creux.