INFO-F-404 : Techniques avancées de systèmes d`exploitation

Nikita Veshchikov
e-mail : [email protected]
téléphone : 02/650.58.56
bureau : 2N8.213
URL : http://student.ulb.ac.be/~nveshchi/
INFO-F-404 : Techniques avancées de systèmes
d’exploitation
Table des matières
1 Rappel théorique
1
1.1 Hypothèses et classifications . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
1
1.2 Algorithmes d’ordonnancement multiprocesseurs . . . . . . . . . . . . . . . . . . . .
2
1.3 Techniques par partitionnement . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
3
1.3.1 Introduction . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
3
1.3.2 RM partitionné . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
3
1.3.3 EDF partitionné . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
3
1.4 Techniques globales . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
4
1.4.1 Optimalité impossible . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
4
1.4.2 Anomalies d’ordonnancement
. . . . . . . . . . . . . . . . . . . . . . . . . .
5
1.4.3 Prédictabilité . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
6
EDF(k)
6
1.4.4 Les algorithmes global EDF et
2 Exercices
. . . . . . . . . . . . . . . . . . . . . .
8
1
1
Rappel théorique
1.1
Hypothèses et classifications
Dans ce TP, nous allons étudier l’ordonnancement temps réel sur des plates-formes multipro-
cesseurs. La première question qui se pose est : “Quel est l’intérêt d’utiliser plusieurs processeurs
au lieu d’un seul ?”. Il y a plusieurs réponses à cette question :
1. La raison principale est financière. Si nous pouvions obtenir une puissance de calcul équivalente à A à l’aide de deux processeurs de puissance
deux processeurs de puissance
A
2
A
2,
alors il est moins coûteux d’acheter
qu’un unique processeur de puissance A.
2. Utiliser une plate-forme multiprocesseur présente également un avantage sur le plan de la
consommation énergétique. De nombreuses études montrent que l’énergie consommée par
un processeur évolue de manière exponentielle par rapport à sa fréquence de fonctionnement, c’est-à-dire sa puissance de calcul. De ce fait, utiliser deux processeurs de puissance
A
2
consomme moins d’énergie que d’utiliser un unique processeur de puissance A.
3. Un comportement similaire a été décelé entre la dissipation de chaleur des processeurs et
leur fréquence de fonctionnement. En ce qui concerne la société Intel, c’est cette augmentation exponentielle de la dissipation de chaleur par rapport à la fréquence de fonctionnement
qui est à l’origine de la conception des processeurs Dual-core au lieu du processeur Pentium 5.
Nous distinguons trois types de plates-formes multiprocesseurs :
1. les plates-formes identiques : tous les processeurs de la plate-forme sont interchangeables
et ont la même puissance de calcul.
2. les plates-formes uniformes : chaque processeur Pi possède sa propre puissance de calcul
si et réalise (si × t) unités de travail lorsqu’il exécute un travail durant t unités de temps.
3. les plates-formes spécialisées : un taux ri,j est associé à chaque couple
( travail Ji , processeur Pj )
avec l’interprétation suivante : Pj réalise (ri,j × t) unités de travail lorsqu’il exécute le travail
Ji durant t unités de temps.
Remarque : Nous avons la relation suivante entre ces différentes architectures :
plates-formes identiques ⊂ plates-formes uniformes ⊂ plates-formes spécialisées.
2
Dans le cadre de ce cours, nous considérons des systèmes fortement couplés, c’est-à-dire
que tous les processeurs de la plate-forme possèdent une base commune du temps et une mémoire commune. Dans la suite, nous considérerons des plates-formes identiques composées de
m processeurs P1 , P2 , . . ., Pm .
1.2
Algorithmes d’ordonnancement multiprocesseurs
On distingue deux types d’approche pour l’ordonnancement multiprocesseur :
1. L’ordonnancement par partitionnement. L’ensemble des n tâches est divisé en m sousensembles disjoints : τ 1 , τ 2 , . . . , τ m . Chaque sous-ensemble τ i est ensuite ordonnancé sur
le processeur Pi avec une stratégie d’ordonnancement locale monoprocesseur (tel que RM,
DM, EDF, etc). Lors de l’ordonnancement, les tâches appartenant à la partition τ i ne sont
jamais autorisées à être exécutée sur un autre processeur que Pi . Avec ce type d’ordonnanceur, chaque processeur Pi possède sa propre file d’attente (sa propre Ready-queue) qui
contient à tout moment les travaux actifs de τ i .
2. L’ordonnancement global. Il s’agit d’appliquer globalement une stratégie d’ordonnancement
sur l’entièreté de la plate-forme multiprocesseur et d’attribuer à chaque instant les m processeurs aux m tâches/travaux les plus prioritaires. Dans ce cas, outre la préemption des
tâches, on autorise aussi la migration de ces dernières ; c’est-à-dire qu’une tâche peut commencer son exécution sur un processeur Pi , être préemptée et reprendre son exécution
ultérieurement sur un autre processeur (disons Pj ). Avec ce type d’ordonnanceur, il n’y a
qu’une seule file d’attente commune à tous les processeurs.
Remarque : Ces deux types d’ordonnancement sont incomparables, c’est-à-dire qu’il existe
des systèmes ordonnançables avec un partitionnement et pour lesquels toute approche globale
échoue, et réciproquement il existe des systèmes ordonnançables avec une approche globale et
pour lesquels tout partitionnement échoue.
1.3
Techniques par partitionnement
1.3.1
Introduction
Le problème de partitionnement est un problème mieux connu sous le nom de Bin Packing qui
consiste à placer dans m boîtes de tailles identiques, n objets de tailles différentes. Ici, les boîtes
sont les processeurs et les objets sont les tâches. Pour les systèmes périodiques à échéance sur
requête, la taille des objets (des tâches) est leur facteur d’utilisation et la taille des boîtes (des
processeurs) est l’utilisation maximale que l’on peut atteindre (ln 2 pour RM et 1 pour EDF). Ce
3
problème de Bin Packing est NP-Hard et on utilise dès lors des heuristiques telles que next-fit,
best-fit, etc. afin d’approcher la solution optimale.
1.3.2
RM partitionné
Pour créer un partitionnement
1
τ , . . . , τ m qui permette à l’algorithme RM d’ordonnancer
localement ces partitions sur chaque processeur Pi ∈ {P1 , . . . , Pm }, on peut utiliser n’importe
quelles heuristiques citées plus haut. Il suffit d’utiliser la condition suffisante
Utot (τ i ) < ni · (21/ni − 1)
afin de vérifier l’ordonnançabilité des tâches de chaque partition τ i par RM (ni dénote le nombre
de tâches appartenant à la partition τ i et assignées au processeur Pi ). Il est cependant possible
de démontrer qu’en utilisant cette borne, on ne peut pas garantir la faisabilité d’un système dont
√
le facteur d’utilisation est supérieur à 2 − 1 ≈ 41% (cf. cours). Cette borne est très contraignante
car elle ne fournit aucun résultat pour un grand nombre de systèmes.
1.3.3
EDF partitionné
En ce qui concerne EDF, nous savons que Utot (τ i ) ≤ 1 est une condition nécessaire et suf
fisante pour chaque partition τ i . Pour créer un partitionnement τ 1 , . . . , τ m qui respecte cette
condition, Lopez et al. ont développé l’algorithme FFDU (First-Fit-Decreasing-Utilization). Le principe est le suivant : on choisit à chaque étape la première boîte (c’est-à-dire le premier processeur) qui convient en considérant les tâches par valeurs décroissantes du facteur d’utilisation. Ces
mêmes chercheurs ont ensuite démontré la condition suffisante d’ordonnançabilité suivante.
Theorem 1 (FFDU, EDF utilisation). Soit τ un système périodique à échéance sur requête. Ce
système est ordonnançable par l’une des partitions FFDU (et EDF localement sur chaque processeur) si :
Utot (τ ) <
1.4
(m + 1)
et Umax (τ ) ≤ 1
2
(1)
Techniques globales
En ce qui concerne les stratégies d’ordonnancement globales, il existe deux résultats (très) négatifs qui sont repris ci-dessous. Heureusement, il existe également certain résultats positifs.
1.4.1
Optimalité impossible
Definition 1 (Algorithmes en ligne). Les algorithmes d’ordonnancement en ligne prennent leur
décision à chaque instant sur base des caractéristiques des travaux qui sont actifs, sans connais4
sance des travaux qui arriveront dans le futur.
Theorem 2. Pour tout m > 1, aucun algorithme d’ordonnancement en ligne et optimal ne peut
exister pour des systèmes avec deux ou plus d’échéances distinctes.
F IGURE 1 – Optimalité impossible
Démonstration. La démonstration se fait pour m = 2 mais il est facile de constater que la preuve
reste valable pour m > 2. Supposons qu’il existe un algorithme d’ordonnancement en ligne optimal
pour deux processeurs et considérons le scénario suivant. A l’instant 0, trois travaux J1 , J2 et J3
arrivent avec J1 = (e1 : 2, d1 : 4), J2 = (e2 : 2, d2 : 4) et J3 = (e3 : 4, d3 : 8). Notre ordonnanceur
optimal n’a que deux choix possibles : il exécute J3 dans l’intervalle de temps [0, 2] ou pas.
1. J3 ne s’exécute pas dans l’intervalle de temps [0, 2] (cf. Figure 1, partie supérieure gauche).
Dans ce cas, à l’instant 4, J3 s’est exécuté pour au plus 2 unités. Donc, à l’instant 4, le
temps de calcul restant de J3 est au moins de deux unités. A présent, supposons que J4 =
(e4 : 4, d4 : 8) et J5 (e5 : 4, d5 : 8) arrivent dans le système. Notre ordonnanceur n’a pas
d’autres choix que d’exécuter J4 et J5 dès l’instant 4 afin de respecter leur échéance. De
cette façon, J3 manquera obligatoirement son échéance à l’instant 8 et on voit qu’il aurait
fallu commencer par exécuter J3 dès l’instant 0 (cf. Figure 1, partie supérieure droite), ce qui
nous conduit au second scénario.
2. J3 s’exécute dans l’intervalle de temps [0, 2] (cf. Figure 1, partie inférieure gauche). Dans
ce cas, au moins l’un des deux travaux J1 ou J2 n’a pas terminé son exécution à l’instant 2.
Puisque J1 et J2 sont identiques, supposons que c’est J2 qui n’a pas terminé à l’instant 2.
A présent, considérons le scénario où J4 = (e4 : 2, d4 : 4) et J5 = (e5 : 2, d5 : 4) arrivent à
l’instant 2. Notre ordonnanceur n’a pas d’autres choix que d’exécuter J4 et J5 dès l’instant 2
afin de respecter leur échéance. Clairement, J2 ne rencontrera pas son échéance à l’instant
4 et on voit qu’il aurait fallu commencer par exécuter J2 à l’instant 0, ce qui nous ramène au
premier scénario.
5
1.4.2
Anomalies d’ordonnancement
Definition 2 (Anomalie). Nous disons qu’un algorithme d’ordonnancement souffre d’anomalies si
un changement qui est intuitivement positif dans un système ordonnançable peut le rendre non
ordonnançable. Nous entendons par “changement intuitivement positif” tout changement qui est
sensé alléger la charge du système (comme par exemple réduire le facteur d’utilisation d’une
tâche ou encore rajouter un processeur à la plate-forme).
Attention : Les algorithmes d’ordonnancement multiprocesseurs sont sujet à des anomalies.
Theorem 3. Le cas périodique synchrone ne correspond pas au pire cas pour les systèmes de
tâches sporadiques en ordonnancement multiprocesseur.
Démonstration. Soit le système de tâches sporadiques τ = {(1, 1, 2), (1, 1, 3), (5, 6, 6)}. L’instance
particulière de τ à démarrage synchrone ayant une activation de tous les jobs dès que possible est
ordonnançable sur m = 2 processeurs en assignant les priorités les plus élevées aux tâches τ1 et
τ2 . Une autre instance de τ où l’activation de la seconde instance de τ1 est retardée d’une unité
de temps est quant à elle malheureusement non ordonnançable, par inspection. Par conséquent,
il n’est pas possible de considérer le cas périodique synchrone comme étant le pire case pour les
systèmes de tâches sporadiques en ordonnancement multiprocesseur.
Actuellement, le pire cas (en terme de temps de réponse) est inconnu pour l’étude des tâches
sporadiques.
1.4.3
Prédictabilité
Nous venons de constater que nous ne disposons pas de la notion de pire cas en ce qui
concerne les tâches sporadiques. En revanche, les algorithmes d’ordonnancement pour les tâches
périodiques/sporadiques sont en général prédictibles.
Definition 3 (Prédictabilité). Soit J = {J1 , . . . , J` } un ensemble de travaux avec Ji = (oi , ei , di ).
Soit S(Ji ) l’instant auquel Ji débute son exécution dans un ordonnancement et, de manière
similaire, soit F (Ji ) l’instant auquel Ji termine son exécution dans un ordonnancement. Soit
J 0 = {J10 , . . . , J`0 } un ensemble de travaux dérivé de J tel que Ji0 = (oi , e0i , di ) et e0i ≤ ei , ∀i. Un algorithme d’ordonnancement A est prédictible si et seulement si on a S(Ji0 ) ≤ S(Ji ) et F (Ji0 ) ≤ F (Ji ),
∀i (1 ≤ i ≤ `), ∀J et ∀J 0 (tel que défini précédemment).
Cette définition introduit le fait que, pour un ordonnanceur prédictible, il est possible de déterminer une borne supérieure sur les temps de réponse des travaux en analysant la situation sous
l’hypothèse que chaque travail prend son pire temps d’exécution pour se terminer. Le caractère
6
prédictible des algorithmes d’ordonnancement est important car il permet de vérifier l’ordonnançabilité en se focalisant uniquement sur les pire temps d’exécution des travaux/tâches et non sur
les durée d’exécution exactes.
Lemme 1. Tous les ordonnanceurs préemptifs, conservatifs et à priorité fixe au niveau des travaux
sont prédictibles lorsqu’ils sont utilisés sur des plates-formes identiques.
Remarque : Les algorithmes non préemptifs sont en général non prédictibles.
1.4.4
Les algorithmes global EDF et EDF(k)
Voici un résultat préliminaire qui concerne l’algorithme “global EDF” :
Theorem 4. Pour un ensemble sporadique à échéance sur requête, la condition suivante est
suffisante pour l’ordonnançabilité sur m processeurs identiques avec “global EDF”.
Utot (τ ) ≤ m − (m − 1) · Umax
ce qui peut se réécrire :
Utot (τ ) − Umax (τ )
m≥
1 − Umax (τ )
(2)
Malheureusement, lorsque Umax se rapproche de l’unité, le nombre m de processeurs nécessaires
obtenu par cette expression tend vers l’infini. Cependant, nous savons qu’un système est faisable
(pour autant que Ci ≤ Di ∀τi ) si le nombre de processeurs est égale au nombre de tâches. Nous
avons donc :
Utot (τ ) − Umax (τ )
m ≥ min n,
1 − Umax (τ )
Lorsque le système considéré n’est composé que d’une unique tâche, on a Utot (τ ) = Umax (τ )
et l’expression ci-dessus devient m ≥ 0. Il est évident que pour n’importe quel système, il doit
toujours y avoir au moins un processeur et donc :
Utot (τ ) − Umax (τ )
m ≥ max 1, min n,
1 − Umax (τ )
Les deux dernières remarques étant évidentes, nous ne considérerons par la suite que l’expression 2. Dans cette section, nous allons voir une variante de l’algorithme global EDF que nous
appelons EDF(k) . Cette variante va notamment permettre de réduire l’Expression 2. Voici les notations que nous allons utiliser :
1. Nous supposons que les tâches sont indexées de telle sorte que U (τ1 ) ≥ U (τ2 ) ≥ . . . ≥
U (τn ).
7
2. Nous notons par τ (i) le système constitué des (n − i + 1) tâches avec les plus petites utilisations de τ :
τ (i) = {τi , τi+1 , . . . , τn }
Voici le fonctionnement de EDF(k) :
Pour toute tâche τi avec i < k :
EDF(k) attribue à τi la plus grande priorité
(il suffit de fixer son échéance à −∞).
Pour toute tâche τi avec i ≥ k :
EDF(k) attribue la priorité de manière similaire à EDF.
Theorem 5. Un système sporadique à échéance sur requête τ est ordonnançable sur m processeurs identiques par l’algorithme EDF(k) , avec
&
U (τ (k+1) )
m = (k − 1) +
1 − U (τk )
'
Theorem 6. Un système sporadique à échéance sur requête τ est ordonnançable sur mmin processeurs identiques par l’algorithme EDF(`) , avec
mmin
(
&
U (τ (k+1) )
= min (k − 1) +
k=1
1 − U (τk )
n
où ` est la valeur de k qui minimise l’expression (k − 1) +
2
l
')
U (τ (k+1) )
1−U (τk )
(3)
m
.
Exercices
Exercice 1 : l’algorithme RM global et partitionné
a)
Trouver un système qui soit ordonnançable par RM global et pas par RM partitionné.
b)
Trouver un système qui soit ordonnançable par RM partitionné et pas par RM global.
Exercice 2 : l’algorithme EDF partitionné
Soit le système temps réel donné à la Table 1. Les tâches sont périodiques, à départ simultané
et à échéance sur requête. Nous supposons qu’elles sont indépendantes entre elles et qu’elles
sont préemptives. Nous supposons également que nous disposons d’une plate-forme composé
de 3 processeurs identiques.
8
Task index
Tâche τ1
Tâche τ2
Tâche τ3
Tâche τ4
Tâche τ5
Tâche τ6
Tâche τ7
Tâche τ8
WCET
10
30
10
50
20
50
250
10
Deadline = Period
50
120
100
200
100
200
300
200
TABLE 1 – Système temps réel composé de 8 tâches périodiques à départ simultané et à échéance
sur requête.
a)
Que nous dit l’expression 1 quant à la répartition des tâches par FFDU ?
b)
Construisez un partitionnement par l’algorithme FFDU.
Exercice 3 : l’algorithme EDF(k)
Soit le système temps réel donné à la Table 2. Les tâches sont périodiques, à départ simultané
et à échéance sur requête. Nous supposons qu’elles sont indépendantes entre elles et qu’elles
sont préemptives.
Task index
Tâche τ1
Tâche τ2
Tâche τ3
Tâche τ4
Tâche τ5
WCET
14
1
2
1
1
Deadline = Period
19
3
7
5
10
TABLE 2 – Système temps réel composé de 5 tâches périodiques à départ simultané et à échéance
sur requête.
a)
Déterminez le nombre de processeurs à utiliser si on emploie l’algorithme global EDF pour
ordonnancer le système.
b)
Déterminez le nombre de processeurs (et donc la valeur optimale de k) à utiliser si on emploie
l’algorithme EDF(k) pour ordonnancer le système.
9