Vous êtes sur la page 1sur 15

COLE POLYTECHNIQUE COLES NORMALES SUPRIEURES

FILIRE MP SPCIALIT INFO

CONCOURS DADMISSION 2015

COMPOSITION DINFORMATIQUE A (XULCR)


(Dure : 4 heures)
Lutilisation des calculatrices nest pas autorise pour cette preuve.
Le langage de programmation pour cette preuve est Caml Light.

Ordonnancement de graphes de tches


Introduction
Voici un problme important qui se pose chacun et chacune de nous tous les jours ! Jai un
certain nombre de tches excuter aujourdhui ; comment planifier quelle heure chacune va
tre excute ? Par exemple, je peux avoir aujourdhui terminer un devoir en mathmatiques,
faire ma lessive la laverie, avancer un projet en informatique, aller faire quelques courses et
repasser mon linge. Chacune de ces tches va me prendre une certaine dure, que je peux estimer.
Mme si ce nest pas tout fait le cas dans la vie courante, on peut ici supposer que les tches
ne sont pas interrompues ; je ne commence une nouvelle tche que lorsque la tche en cours est
termine.

Dpendances. Le plus souvent, il existe des dpendances entre les tches, en ce sens quil est
ncessaire dexcuter une tche A avant dexcuter une tche B. Par exemple, il est ncessaire de
laver le linge avant de le repasser. Mais, si je nai plus de lessive, il est ncessaire de passer faire
les courses avant daller la laverie. Ces dpendances peuvent tre modlises par un graphe
orient. Les nuds sont les tches, les arcs orients sont les dpendances. Il y a un arc A B si
la tche A doit tre termine avant que la tche B puisse commencer. Notez quil nest pas du
tout ncessaire de passer reprendre son linge la laverie ds que la machine sarrte. La tche B
peut tre ordonnance longtemps aprs que la tche A sera termine.

Ordonnancement. Un ordonnancement est la donne dune heure dexcution pour chacune


des tches qui respecte cette contrainte quune tche commence seulement lorsque toutes celles
dont elle dpend sont termines. Notez quil peut y avoir des moments de repos o aucune tche
nest en excution. La mesure intressante est alors la dure dexcution totale, cest--dire la
dure coule entre lheure laquelle lexcution de la premire tche commence et lheure
laquelle celle de la dernire tche se termine.

Paralllisme. Si je suis seul, je ne peux excuter quune tche la fois. Mais je peux aussi
me faire aider ! Il est alors possible dexcuter plusieurs tches en parallle. Par exemple, je
peux demander quelquun de faire ma lessive la laverie, pour aller faire mes courses pendant
ce temps et ensuite revenir la prendre pour la repasser. En termes informatiques, on parle de
multiples processeurs qui collaborent pour le traitement des tches. Dans notre exemple, deux
processeurs travaillent en parallle : lun pour faire la lessive, lautre pour faire les courses.
chaque instant, plusieurs tches peuvent tre excutes, au plus autant que de processeurs.
Notez quil est cependant possible quun processeur soit forc de rester inactif un certain temps,
par exemple parce que la tche quil doit excuter dpend dune autre tche qui est en cours
dexcution sur un autre processeur.

Dfi algorithmique. Les exemples ci-dessus sont bien sr des illustrations simplifies. En
pratique, on va considrer des graphes de tches de taille gigantesque, par exemple lensemble
des actions ncessaires pour assembler un avion. Ces graphes comptent des millions de tches
avec des dpendances complexes. Les tches seront alloues des ouvriers. Ceux-ci travaillent
lintrieur dhoraires fixs, avec des priodes de repos, des vacances, des arrts imprvus pour
cause de maladie ou de panne de machine. Lobjectif sera de trouver le meilleur ordonnancement
possible pour lassemblage selon une mesure donne. Notez que dans ce cas, le graphe est fixe,
mais le nombre douvriers peut varier : on peut par exemple embaucher plus douvriers pour
rduire la dure dexcution totale. Cela augmente le cot de production mais rduit les dlais
de livraison. Trouver un ordonnancement optimal est alors un dfi algorithmique majeur.

Plan du sujet propos. La partie I introduit la notion dordonnancement dun graphe de


tches. La partie II sintresse quelques proprits des graphes de tches acycliques. La partie III
tudie une premire approche pour la recherche dun ordonnancement dun graphe de tches.
Lordonnancement produit est optimal avec p = 1 processeur, mais pas avec p > 1. La partie IV
tudie comment modifier cette approche pour produire un ordonnancement optimal avec p = 2
processeurs dans le cas particulier des arbres arborescents entrants. La partie V dcrit comment
complter cette approche et obtenir un ordonnancement optimal avec p = 2 processeurs dans le
cas gnral.
Les parties peuvent tre traites indpendamment. Nanmoins, chaque partie utilise des notations et des fonctions introduites dans les parties prcdentes.
La complexit, ou le cot, dun algorithme ou dune fonction Caml est le nombre doprations
lmentaires ncessaires son excution dans le pire cas. La notion dopration lmentaire
sera prcise dans chaque cas par le sujet. Lorsque cette complexit dpend dun ensemble de

(a) Un graphe de tches tout


simple.

(b) Un graphe de tches plus


complexe sans cycle.

(c) Un graphe de tches avec un


cycle : c, e, f, d.

Figure 1 Quelques exemples de graphes de tches.


paramtres (n, p, . . . ), on pourra donner cette estimation sous forme asymptotique. On rappelle
quune application c(n, p, . . . ) est dans la classe O(f ) sil existe une constante > 0 telle que
|c(n, p, . . . )| < f (n, p, . . . ), pour toutes les valeurs de n, p, . . . assez grandes.

Dfinitions de base

Graphe de tches. Un graphe de tches G = (T, D, ) est constitu dun ensemble fini et non
vide T de tches notes u, v, etc.
Lapplication associe chaque tche du graphe sa dure. Dans tout ce problme, on supposera que la dure dune tche est unitaire : (u) = 1.
Lensemble D T T est un ensemble darcs (dirigs) entre ces tches (D pour dpendance,
voir plus loin). Lexistence dun arc (u, v) dans D est note u v. On suppose quil ny a pas
darc entre une tche et elle-mme : D {(u, u)|u T } = .
Il y a un arc dirig (u, v) dune tche u vers une autre tche v distincte, u 6= v, si la tche u
doit tre excute avant la tche v. On dit alors que la tche v dpend de la tche u en ce sens
que v ne peut commencer quune fois que u est termine. On dit alors que u prcde v ou que la
tche v succde la tche u. On peut donc parler de lensemble des tches qui prcdent v et de
lensemble des tches qui succdent u. Notez que ces ensembles peuvent tre vides.
Une tche qui na aucun prdcesseur sappelle une racine. Une tche qui na aucun successeur
sappelle une feuille.
La taille dun graphe de tches est le nombre de ses tches.
La figure 1 propose quelques exemples de graphes de tches de petite taille.

Ordonnancement. Un ordonnancement dun graphe de tches G = (T, D, ) est une application valeurs entires qui associe une date dexcution chaque tche du graphe, dans le
respect des contraintes de dpendance spcifies par la formule (1) ci-dessous.
Une tche u T est excute de manire ininterrompue par le processeur qui en a la charge
aux instants t tels que (u) t < (u)+ (u). Une tche v qui dpend de u ne peut tre excute
quaprs la terminaison de u, donc partir de linstant (u) + (u). Un ordonnancement doit
donc respecter la contrainte suivante :
u, v T, (u v) ((u) + (u) (v))

(1)

Linstant a du dbut de lordonnancement du graphe de tches G = (T, D, ) est linstant


o la premire tche est excute : a = minuT (u).
Linstant b de la fin de lordonnancement est linstant o la dernire tche est termine :
b = maxuT ((u) + (u)).
La dure dexcution totale de lordonnancement est b a .
Lensemble St des tches en cours dexcution linstant t est dfini par :
St = {u | (u) t < (u) + (u)}
Dans notre cas, (u) = 1 pour toute tche u et cette formule se simplifie :
St = {u | (u) = t}
On dit quun ordonnancement utilise (au plus) p processeurs si cardinal(St ) p tout instant t.
On dit quun ordonnancement est optimal pour un graphe de tches G avec p processeurs
si sa dure dexcution est minimale parmi tous les ordonnancements possibles de G avec p
processeurs.
La figure 2 propose quelques exemples dordonnancements de graphes de tches. On rappelle
que chaque tche u dure une unit de temps : (u) = 1. La date dexcution de chaque tche est
indique gauche de cette tche.
1. Lordonnancement prsent en figure 2a a une dure dexcution totale de 10 avec p = 1
processeur. Il nest pas optimal. En effet, aucune tche nest excute linstant 5 o la
tche e est prte ; il serait donc possible de rduire la dure dexcution totale 9. Ce
serait alors optimal puisquil y a 9 tches, chacune de dure 1.
2. Lordonnancement prsent en figure 2b a une dure dexcution totale de 5 avec p = 2
processeurs. Comme il y a 8 tches pour 2 processeurs, tout ordonnancement a une dure
au moins gale 4. Cependant, les contraintes de dpendance ne permettent pas de
raliser un ordonnancement de dure 4. Un ordonnancement de dure dexcution totale
5 est donc optimal.
3. Le graphe de tches de la figure 2c comporte un cycle : c e f d. Aucune tche
dun cycle ne peut tre excute en respectant les contraintes de dpendance.
4

(a) Un ordonnancement pour le


graphe de tches de la figure 1a
avec p = 1 processeur.

(b) Un ordonnancement pour le


graphe de tches de la figure 1b
avec p = 2 processeurs.

(c) Un graphe de tches avec un


cycle nadmet pas dordonnancement.

Figure 2 Quelques exemples dordonnancement de graphes de tches.


Objectif. Lobjectif de ce problme va tre de dterminer des ordonnancements optimaux pour
certaines classes de graphes de tches pour un nombre p donn de processeurs.

II

Graphe de tches acyclique

Un chemin de dpendance dans un graphe de tches dune tche u une tche v est une suite
de tches (u0 , u1 , . . . , un ), n 0, avec u0 = u et un = v et en dpendance successive : u0 u1 ,
u1 u2 , . . ., un1 un .
La longueur du chemin est le nombre darcs de dpendance, cest--dire lentier n. La tche
initiale du chemin est u0 , sa tche terminale un . Notez quune tche peut apparatre plusieurs
fois dans un chemin. Notez aussi quun chemin peut tre de longueur nulle. Il a alors la mme
tche initiale et terminale.
Une tche u est atteignable depuis une tche u0 sil existe un chemin qui a pour tche initiale
u0 et pour tche terminale u.
Un cycle dans un graphe de tches est un chemin (u0 , u1 , . . . , un ) de longueur n > 0 qui a
mme tche initiale et terminale : u0 = un .
Un graphe de tches est dit acyclique sil ne possde pas de cycle. Les graphes de tches des
figures 1a et 1b sont acycliques, celui de la figure 1c possde un cycle.
On veut maintenant montrer quil nexiste pas dordonnancement pour un graphe de tches
qui possde un cycle.
Question 1. Soit G = (T, D, ) un graphe de tches qui admet un ordonnancement . Dmontrez
que sil existe un chemin de dpendance de longueur non nulle dune tche u vers une tche v
dans G, alors (u) < (v). En dduire que G est ncessairement acyclique.
 On pourra procder par rcurrence sur la longueur n du chemin aprs avoir soigneusement

spcifi la proprit H(n) dmontre par rcurrence.


5

let graph = make_graph ();;


let
let
let
let
let
let
let
let

a = make_task 1 "a";;
b = make_task 1 "b";;
c = make_task 1 "c";;
d = make_task 1 "d";;
e = make_task 1 "e";;
f = make_task 1 "f";;
g = make_task 1 "g";;
h = make_task 1 "h";;

add_task
add_task
add_task
add_task
add_task
add_task
add_task
add_task

a graph;;
b graph;;
c graph;;
d graph;;
e graph;;
f graph;;
g graph;;
h graph;;

add_dependence
add_dependence
add_dependence
add_dependence
add_dependence
add_dependence
add_dependence
add_dependence
add_dependence

a c graph;;
a d graph;;
b d graph;;
b g graph;;
c e graph;;
d f graph;;
e h graph;;
f h graph;;
g h graph;;

Table 1 Comment construire le graphe de la figure 1b avec la bibliothque Graph.

Avant de chercher un ordonnancement dun graphe de tches, il faut donc vrifier quil est
acyclique. La proprit suivante fournit une condition ncessaire. On rappelle quun graphe de
tches est constitu dun nombre fini et non nul de tches.
Question 2. Soit G = (T, D, ) un graphe de tches. Montrez que si G est acyclique, alors G a
ncessairement au moins une racine et une feuille.
Dans toute la suite du problme, on suppose quon dispose dune certaine bibliothque Caml
appele Graph qui permet de manipuler des graphes de tches. Cette bibliothque regroupe des
fonctions qui sont disponibles pour les utilisateurs, mme sils nen connaissent pas le code. On
pourra donc utiliser librement toutes les fonctions de cette bibliothque sans les rcrire. Cette
bibliothque dfinit deux types de donnes : graph pour les graphes de tches, et task pour les
tches. Elle propose les fonctions listes en table 2 pour manipuler ces deux types. La table 1
montre comment on pourrait construire le graphe de la figure 1b avec ces fonctions.
On rappelle quelques fonctions Caml Light permettant de manipuler les tableaux et dimprimer.
make_vect n a renvoie un nouveau tableau de n lments qui contiennent tous la mme
valeur a.
vect_length tab renvoie la longueur (le nombre dlments) n du tableau tab. Ceux-ci sont
indexs de 0 n 1 inclus.
tab.(i) renvoie la valeur de llment dindice i du tableau tab.
tab.(i) < a affecte la valeur a llment dindice i du tableau tab.
sub_vect tab i n renvoie le sous-tableau de tab constitu de n lments partir de lindice
i inclus.
print_int n imprime lentier n.
print_string s imprime la chane s.
print_newline () passe la ligne suivante.
Voici par exemple comment imprimer lensemble des successeurs dune tche :
let print_successors t =
let tab = get_successors t in
for i = 0 to (vect_length tab) 1 do
print_string (get_name (tab.(i))); print_string ""
done;
print_newline ();;

make_graph: unit > graph


make_task: int > string > task

Cre un graphe vide.


Cre une tche dune dure donne avec un nom
donn.
(Attention, une erreur se produit si le nom a dj
t utilis pour la cration dune autre tche.)
Une tche vide, diffrente de toutes les tches
cres par la fonction make_task.
(Attention, une erreur se produit si on applique
les fonctions de manipulation de tches ci-dessous
autres que is_empty_task cette tche.)
Teste si une tche est la tche empty_task
Renvoie la dure dune tche.
Renvoie le nom dune tche.
Ajoute une tche au graphe.
Renvoie le tableau des tches du graphe.
Ajoute un arc de dpendance au graphe, de la
premire vers la seconde tche.
(Attention, une erreur se produit si les tches
nexistent pas dans le graphe.)
Renvoie le tableau des tches successeurs dune
tche donne.
(Attention, une erreur se produit si la tche
nexiste pas dans le graphe.)
Renvoie le tableau des tches prdcesseurs dune
tche donne.
(Attention, une erreur se produit si la tche
nexiste pas dans le graphe.)

empty_task: task

is_empty_task: task > bool


get_duration: task > int
get_name: task > string
add_task: task > graph > unit
get_tasks: graph > task vect
add_dependence: task > task > graph > unit

get_successors: task > graph > task vect

get_predecessors: task > graph > task vect

Table 2 La table des fonctions de la bibliothque Graph de manipulation de graphes de tches.

Question 3. crivez en Caml les fonctions suivantes :


1. count_tasks: graph > int : renvoie le nombre de tches dun graphe de tches.
2. count_roots: graph > int : renvoie le nombre de ses tches racines.
Question 4. crivez en Caml une fonction make_root_array: graph > task vect qui renvoie le
tableau des tches racines du graphe. On pourra si ncessaire renvoyer un tableau plus grand que
le nombre de racines. Il sera dans ce cas complt par la tche empty_task.
 Un tableau est complt par une valeur u si cette valeur napparat pas dans le tableau, ou

alors, si elle apparat, elle napparat pas jusqu un certain indice, puis seule cette valeur
apparat au-del de cet indice.

III

Ordonnancement par hauteur

On sintresse la recherche dun ordonnancement dun graphe acyclique donn G de


n 1 tches sur un ensemble de p processeurs. On rappelle que chaque tche u dure une unit
de temps : (u) = 1.
7

set_tag: int > task > unit

get_tag: task > int

has_tag: task > bool

Affecte une tiquette une tche.


(Attention, une erreur se produit si une tiquette
a dj t affecte cette tche.)
Renvoie ltiquette dune tche.
(Attention, une erreur se produit si aucune
tiquette na t affecte cette tche.)
Renvoie vrai si ltiquette de la tche a t dfinie
par la fonction set_tag et faux sinon.

Table 3 La table des fonctions complmentaires pour la manipulation des tiquettes valeurs
entires des tches.

Une tche peut tre ordonnance seulement si toutes les tches dont elle dpend lont dj
t. Trouver un ordonnancement dun graphe G acyclique avec un seul processeur revient donc
numrer les tches de ce graphe dans un ordre (total) qui respecte les contraintes de dpendance.
Il est donc intressant dtiqueter le graphe de tches selon ces contraintes.
Pour manipuler les tiquettes valeurs entires des tches, on tend la bibliothque Graph
avec les fonctions sur les tches dcrites en table 3.
Cet tiquetage fonctionne de la manire suivante : une tche v reoit une tiquette tag(v)
portant un numro strictement suprieur celui de toutes les tiquettes tag(u) des tches u telles
que u v. Notez que plusieurs tches peuvent recevoir la mme tiquette.
Algorithme 1 (tiquetage par hauteur depuis les racines).
1. Initialement, aucune tche nest tiquete.
2. litration dordre k = 0, on parcourt lensemble des tches et on affecte ltiquette 0
aux tches racines.
3. litration k > 0, on parcourt lensemble des tches en reprant toutes les tches
qui nont pas encore t tiquetes mais dont toutes les tches prdcesseurs sont dj
tiquetes. On affecte ensuite chacune de ces tches ltiquette k.
4. Lalgorithme termine quand toutes les tches sont tiquetes.
On dira dune tche qui a reu ltiquette k quelle porte ltiquette k.
La figure 3a prsente un exemple dtiquetage selon lalgorithme 1. Les tiquettes sont notes
dans les cercles griss droite des tches.
Question 5. crivez une fonction Caml check_tags_predecessors: task > bool qui prend en
paramtre une tche et renvoie vrai si toutes ses tches prdcesseurs dans le graphe de tches sont
tiquetes et faux sinon. En particulier, la fonction renvoie vrai si la tche ne dpend daucune
tche (cest une racine).
Question 6. crivez une fonction Caml label_height: graph > unit qui prend en paramtre un
graphe de tches et affecte chaque tche une tiquette selon lalgorithme 1. Veillez bien ce
quaucune erreur ne puisse se produire lors des appels des fonctions de la bibliothque Graph.
8

(a) Un tiquetage par hauteur (b) Un ordonnancement pour le


du graphe de tches de la fi- graphe de tches de la figure 1b
gure 1b.
avec p = 1 processeurs.


(c) Un ordonnancement pour le
graphe de tches de la figure 1b
avec p = 2 processeurs.

Figure 3 Un exemple dtiquetage par hauteur et un ordonnancement associ.


 Pour chaque valeur de ltiquette k, on pourra par exemple dans un premier temps reprer

lensemble des tches tiqueter, puis dans un second temps tiqueter ces tches. Chacune
de ces deux actions pourra tre implmente par une fonction auxiliaire.

Soit G un graphe de tches. Soit u une tche de G. Soit Pu lensemble des chemins de la
forme (u0 , u1 , . . . , un ), o u0 est une racine de G et un = u. La tche u admet un chemin critique
amont si Pu est non vide et si lensemble des longueurs des chemins de Pu est major. Les chemins
critiques amont de u sont alors les chemins de Pu de plus grande longueur. En particulier, le
chemin critique amont dune racine est de longueur nulle et il est unique.
Considrons un graphe de tches G qui possde un cycle. Soit u une tche dun cycle de G.
Supposons que Pu soit non vide. Alors, il existe une racine u0 de G telle que u soit atteignable
de cette racine. On peut produire des chemins arbitrairement longs de u0 u en parcourant le
cycle de manire rpte. La tche u nadmet donc pas de chemin critique amont.
Question 7. Soit G un graphe de tches acyclique. Montrez que toutes ses tches admettent des
chemins critiques amont.
Question 8. Supposons que G soit acyclique. Dmontrez quune tche u reoit ltiquette de
valeur k dans lalgorithme 1 si et seulement si la longueur commune des chemins critiques amont
de u est k.
Question 9. En dduire que lalgorithme termine si et seulement si le graphe est acyclique.
Montrez par un exemple ce qui se produit si le graphe possde un cycle.
Question 10. Dmontrez que si une tche u porte une tiquette k, alors elle ne pourra tre
ordonnance quau moins k units de temps aprs que la premire tche a t ordonnance, quel
que soit lordonnancement mais aussi quel que soit le nombre de processeurs utiliss.
Soit G un graphe de tches acyclique. Soit kmax la valeur maximale des tiquettes attribues
aux tches de G par lalgorithme 1. Soit Tmax lensemble des tches de G qui reoivent cette
tiquette kmax . Les chemins critiques amont des tches de Tmax sont appels chemins critiques
de G. Ces chemins comportent kmax + 1 tches de dure unitaire. Selon la question 10, la dure
dexcution totale du graphe de tches est donc minore par kmax + 1.
9

Une fois un graphe de tches G tiquet selon lalgorithme 1, il est possible de dterminer un
ordonnancement avec p processeurs en excutant les tches par niveau selon la valeur de leurs
tiquettes. Soit Tk lensemble des tches qui portent ltiquette k.
Algorithme 2 (algorithme dordonnancement par hauteur pour p processeurs). Pour chaque
valeur de k entre 0 et kmax , on excute les tches de Tk par lots de p tches. Pour chaque valeur
k, le dernier lot pourra tre incomplet. Les processeurs inutiliss sont alors inactifs.
Les figures 3b et 3c prsentent des ordonnancements obtenus par cet algorithme partir
de ltiquetage de la figure 3a, respectivement pour p = 1 et p = 2 processeurs. On notera en
particulier que dans la figure 3c la tche e reoit ltiquette 4 et non 3.
Un ordonnancement sera imprim de la manire suivante. Chaque ligne entre Begin et End
liste les tches excutes un instant donn. Il y a une ligne par instant entre le dbut et la fin de
lordonnancement. Le nombre de ligne est donc la dure totale dexcution de lordonnancement.
Begin
uvw
xy
...
z
End

 On pourra utiliser la fonction get_name de la bibliothque Graph pour obtenir le nom des

tches et utiliser la fonction print_string pour limprimer.

Question 11. crivez une fonction Caml schedule_height: graph > int > unit qui prend en
paramtres un graphe G de tches tiquetes par lalgorithme 1 et un nombre p de processeurs
et qui imprime pour chaque instant t la liste des noms des tches (au plus p) excutes selon
lalgorithme 2 selon le format ci-dessus.
 On pourra par exemple diviser le traitement en plusieurs actions implmentes par des fonc-

tions auxiliaires. Pour chaque valeur de ltiquette k, on extrait lensemble des tches
portant cette tiquette. On imprime ensuite cet ensemble par lots de p tches, avec un lot
par ligne, le dernier lot tant ventuellement incomplet.

Une opration lmentaire de lalgorithme est daccder une tche par lune des fonctions
des bibliothques prsentes dans les tables 2 et 3. On suppose que chaque opration lmentaire
cote 1.
Question 12. Estimez la complexit de votre fonction schedule_height pour lordonnancement
dun graphe de n tches tiquetes par lalgorithme 1 avec p processeurs.
Question 13. Justifiez que lordonnancement ainsi obtenu est optimal pour un seul processeur,
cest--dire quand p = 1.
Un graphe de tches acyclique arborescent sortant est un graphe avec une unique racine dans
lequel chaque tche sauf cette racine a exactement un prdcesseur. Cest par exemple le cas du
10

(a) Un graphe de tches arborescent sortant.

(b) Un graphe de tches arborescent entrant.

Figure 4 Quelques exemples de graphes de tches arborescents.


graphe de la figure 4a. Un graphe de tches acyclique arborescent entrant est un graphe avec une
unique feuille dans lequel chaque tche sauf cette feuille a exactement un successeur. Cest par
exemple le cas du graphe de la figure 4b.
Question 14. Appliquez lalgorithme 1 aux deux graphes de tches de la figure 4 pour p = 2
processeurs. Quelle est la dure totale dexcution des ordonnancements produits ? Montrez que
ces ordonnancements ne sont pas optimaux pour p = 2 processeurs en dcrivant pour chacun des
graphes un ordonnancement dont la dure totale dexcution est strictement plus courte.

IV

Ordonnancement par profondeur : lalgorithme de Hu

On suppose dans toute la suite du problme que tous les graphes de tches considrs sont
acycliques.
Ltiquetage par hauteur ne fournit pas assez dinformations pour ordonnancer les tches
de manire optimale car il sappuie sur la structure du graphe en amont des tches tiquetes.
La figure 5 dcrit par exemple deux ordonnancements du mme graphe dans lequel les tches
excutes sont excutes dans lordre croissant des tiquettes de hauteur. Cependant, lordonnancement 5a conduit lun des processeurs rester inactif alors que lordonnancement 5b permet
lutilisation constante des deux processeurs.
Lide de cette partie est de mettre en place un autre tiquetage, cette fois-ci fond sur les
plus longs chemins de tches en aval. En effet, la question 16 ci-dessous montrera que la longueur
des plus longs chemins de tches en aval dune tche limite infrieurement la dure dexcution
au-del de cette tche. Il sera donc intressant dexcuter les tches avec les plus longs chemins
de tches en aval le plus tt possible. Cest ce que nous ferons dans lalgorithme 4 ci-dessous d
Hu.

11


(a) Un ordonnancement pour
p = 2 processeurs obtenu avec
la mthode par hauteur fournissant une dure dexcution totale de 5.


(b) Un ordonnancement optimal pour p = 2 processeurs
fournissant une dure dexcution totale de 4.

(c) Ltiquetage par profondeur.

Figure 5 Un graphe de tches pour lequel la mthode dordonnancement par hauteur de la


section III ne fournit pas un ordonnancement optimal pour p = 2 processeurs.
Il suffit donc dadapter lalgorithme 1 pour tiqueter les tches partir des feuilles au lieu
des racines.
Algorithme 3 (tiquetage par profondeur depuis les feuilles).
1. Initialement, aucune tche nest tiquete.
2. litration dordre k = 0, on parcourt lensemble des tches et on affecte ltiquette 0
aux tches feuilles.
3. litration k > 0, on parcourt lensemble des tches en reprant toutes les tches qui
nont pas encore t tiquetes mais dont toutes les tches successeurs sont dj tiquetes.
On affecte chacune de ces tches ltiquette k.
4. Lalgorithme termine quand toutes les tches sont tiquetes.
La figure 5c prsente un exemple dtiquetage obtenu par lalgorithme 3.
Question 15. Expliquez comment adapter la fonction label_height de la question 6 pour obtenir
une fonction label_depth: graph > unit qui affecte chaque tche une tiquette selon lalgorithme 3.
Soit G un graphe de tches. Soit u une tche de G. Soit Pu lensemble des chemins de la
forme (u0 , u1 , . . . , un ), o u0 = u et un est une feuille de G. La tche u admet un chemin critique
aval si Pu est non vide et si lensemble des longueurs des chemins de Pu est major. Un chemin
critique aval de u est un chemin de plus grande longueur dans lensemble Pu .
Considrons un graphe de tches G. (On rappelle que les graphes de tches sont supposs
acycliques ici.) Comme pour les chemins critiques amont, toutes les tches u de G admettent
des chemins critiques aval. La profondeur dune tche u, depth(u), est la longueur commune des
chemins critiques aval de u.
Question 16. Soit G un graphe de tches acyclique. Soit u une tche de G de profondeur h.
Supposons que u soit excute linstant t. Montrez que lordonnancement de G ne pourra pas
terminer avant linstant t + h + 1 quel que soit le nombre de processeurs utiliss.
12

Init, Ready, Done


set_state: state > task > unit
get_state: task > state

Les valeurs du type state.


Affecte un tat une tche.
Renvoie ltat dune tche.
(On suppose que ltat des tches est initialis
Init lors de leur cration.)

Table 4 La table des fonctions complmentaires pour la manipulation des tats des tches.

Une tche est dite prte tre excute un instant t si toutes les tches dont elle dpend
ont t dj excutes.
Algorithme 4 (algorithme de Hu pour p processeurs). Soit G un graphe de tches acyclique.
On construit un ordonnancement de G pour p processeurs de manire suivante.
1. Lordonnancement commence linstant t0 = 1.
2. chaque instant t t0 , on considre lensemble Rt des tches de G prtes tre excutes.
Soit r le cardinal de cet ensemble.
3. Si r p, on choisit pour tre excutes linstant t les r tches de Rt et p r processeurs
restent inactifs.
4. Sinon, on trie les tches de Rt par ordre dcroissant de profondeur et on choisit pour tre
excutes linstant t les p premires tches.
5. Lordonnancement se termine quand toutes les tches de G ont t excutes.
On notera que le caractre acyclique de G garantit quil y a toujours au moins une tche
prte tant quil reste dans G une tche non excute.
Question 17. Appliquez lalgorithme de Hu aux graphes de tches des figures 4a et 4b pour p = 2
processeurs. Quelles sont les dures dexcution totales obtenues ?
Pour crire lalgorithme en Caml, il sera commode de manipuler les tats des tches grce aux
fonctions de la table 4. Ces tats appartiennent un type state qui contient les valeurs suivantes.
Une tche est dans ltat initial Init si elle na pas encore t traite. Cest en particulier le cas
lors de sa cration par la fonction make_task. Elle est dans ltat Ready si toutes les tches dont
elle dpend ont t excutes. Elle est dans ltat Done si elle a t excute.
 Ltat de la tche empty_task nest pas dfini.

Question 18. crivez une fonction Caml is_ready: task > bool qui renvoie vrai si toutes les
tches dont dpend la tche passe en argument sont dans ltat Done et faux sinon. En particulier,
la fonction renvoie vrai si la tche passe en argument ne dpend daucune tche.
Pour implmenter lalgorithme 4, il faudra trier les tches du graphe G selon la valeur de
leurs tiquettes, par ordre dcroissant. On supposera donc quon dispose dune fonction Caml
sort_tasks_by_decreasing_tags: task vect > task vect qui ralise une telle opration. Attention,
une erreur se produit si ltiquette dune des tches du tableau nest pas dfinie, sauf si cest
la tche spciale empty_task. Cette tche est considre plus petite que toutes les autres tches
dans le tri.
13

Figure 6 Un graphe de tches... un peu pathologique.


Question 19. crivez une fonction Caml schedule_Hu: graph > int > unit qui prend en paramtres un graphe G de tches tiquetes par lalgorithme 3 et un nombre p de processeurs et
qui imprime pour chaque instant t la liste des tches (au plus p) excutes selon lalgorithme de
Hu. Limpression doit avoir la mme forme que pour la question 11.
 On pourra par exemple diviser le traitement en plusieurs actions implmentes par des fonc-

tions auxiliaires.

Une opration lmentaire de lalgorithme est daccder une tche par lune des fonctions des
bibliothques prsentes dans les tables 2, 3 et 4. On suppose que chaque opration lmentaire
cote 1. On suppose que lappel la fonction sort_tasks_by_decreasing_tags sur un tableau de
taille n cote n log2 (n).
Question 20. Estimez la complexit de votre fonction schedule_Hu pour lordonnancement dun
graphe de n tches tiquetes par lalgorithme 3 avec p processeurs.
On peut montrer que lalgorithme de Hu est optimal pour les graphes de tches arborescents
entrants comme celui de la figure 4b avec un nombre de processeurs p arbitraire. La preuve de
ce rsultat est dlicate, mais lune des cls de la preuve est la proprit suivante.
Question 21. Soit G un graphe de tches arborescent entrant avec p processeurs. Montrez que
dans lalgorithme de Hu le cardinal de lensemble Rt de tches prtes dans G ne peut pas crotre
au cours de lalgorithme.
Cette proprit est spcifique du caractre arborescent entrant comme le montre lexemple
de la figure 6.
Question 22. Montrez que lalgorithme de Hu ne conduit pas ncessairement un ordonnancement optimal avec p = 2 processeurs pour le graphe de tches de la figure 6.
 On montrera quil existe rarrangement tri des tches de ce graphe qui conduit un ordon-

nancement non optimal.

Question 23. Montrez que lalgorithme de Hu est optimal pour les graphes de tches arborescents entrants avec p processeurs.
 Cette preuve est dlicate. Un approche possible est dexaminer lactivit des processeurs au

cours dun ordonnancement. On peut montrer qu partir de linstant o les processeurs


ne sont plus tous actifs, lexcution est conditionne par un chemin critique du graphe.
Ainsi, lordonnancement utilise toujours au mieux les processeurs disponibles.
14

Conclusion

Ce problme a t initialement tudi par T. C. Hu du centre de recherche IBM de Yorktown


Heights en 1961. lpoque, il sagissait dorganiser le travail douvriers sur une ligne de montage.
La preuve doptimalit dont ce sujet sest inspir a t propose par James A. M. McHugh en
1984.
Lalgorithme de Hu consiste en fait dfinir une mesure de priorit sur les tches ordonnancer. La mesure considre est la profondeur de la tche. Les tches sont ordonnances en
privilgiant celles de plus grande priorit. Lexemple de la figure 6 montre que cette approche
nest cependant pas adapte des graphes o des tches ont des dpendances multiples. Dans ce
cas, il est important de privilgier certaines tches par rapport dautres parmi toutes les tches
de mme profondeur.
En 1972, E. G. Coffman, Jr. et R. L. Graham ont propos une amlioration de cette mesure
de priorit. Lide est de dpartager les tches de profondeurs gales en privilgiant parmi elles
celles qui ont les successeurs les plus profonds en un certain sens. Cet algorithme conduit un
ordonnancement optimal pour les graphes de tches quelconques, pour p = 2 processeurs.
Malheureusement, il ne lest pas pour le cas p 3. Cependant, on peut montrer que tous les
algorithmes tudis ci-dessus conduisent des ordonnancements dont la dure dexcution totale
nest pas plus du double de la dure optimale. Cette approximation est heureusement suffisante
dans un grand nombre dapplications.

15