Mesi Ordo Nmachines PDF

ORDONNANCEMENT
Problèmes à N machines
Module
Modélisation et Évaluation des Systèmes
Informatiques
Laurent PHILIPPE
LIFC
Master 2 Informatique 2011 1
N machines
Différents cas : α | β | γ
α = P, Pm ou P : machines identiques
α = Q ou Qm: machines uniformes
α = R ou Rm: machines unrelated
Applications :
β = pj=1 : tâches unitaires
β = pj : tâches indépendantes
β = prec, pj : tâches avec contrainte de précédence
Ajout de mj = taille (parallélisme) du job j
Modèles théoriques ressources
Sharedmemory:
Ordonnancement sur les cœurs
Pas de délais de communication
PRAM (Parallel Random Access Machine):
Nombre de processeurs infini
Hiérarchie de mémoires (locale, globale)
Distributed memory (cluster):
Prise en compte des communications
Homogènes
Grappes/grilles:
Hétérogènes
Modèles théoriques applications
©D. Tristram 03
Solutions générales
Applications parallèles :
bag of tasks : simulations d'éléments sans interactions mj = 1
graphes de tâches : DAG
parallélisation de code : granularité
Critères peuvent varier :
Terminer l'exécution d'une application au plus tôt : Cmax
Partager au mieux une machine parallèle (nonclairvoyant)
Ordonnancement en 2 étapes :
Répartition entre les machines
Ordonnancement local à la machine
Solutions
Certains cas ne posent pas vraiment de pb:
Pm | pj=1 | Cmax : Cmax(OPT) = ⌈1/m (∑i pi)⌉
P | | Cmax : Cmax(OPT) = maxi ( pi )
P | prec | Cmax : Cmax(OPT) = chemin critique
Suite : cas mj = 1
Cas Pm || Cmax
Jobs : J = { J1, ..., Jn} indépendants avec :
Temps d'exécution pi
Machines : Mi, homogènes (P)
Sans préemption:
1
Cmax OPT max {max {pi }, . ∑ pi }
m
Répartition de la charge sur les machines ou job dominant.
Avec préemption :
1
Cmax OPT =max {max {pi }, . ∑ pi }
m
Répartition équilibrée entre les machines ou job dominant.
Cas Pm || Cmax
Les ordonnancements optimaux sont sans délais
Problème NPDifficile
Algorithme de liste [Graham 66]:
Les jobs sont ordonnés en liste en fonction d'un critère :
LPT/SPT : Largest/Smallest Processing Time First
EDF : Earliest Deadline First
Random
Attribution du job : machine qui le termine au plus tôt
Machine exécute le premier job disponible dans sa liste
Cas Pm || Cmax
Caractérisation de LPT :
facteur d'approximation (compétitivité):
Cmax  LPT  4 1
 −
Cmax OPT  3 3m
résultat optimal inconnu mais Cmax(OPT) admet
une borne inférieure :
1
Cmax OPT  .∑ pi
m
Preuve LPT
Si l'affirmation est fausse, il existe un contreexemple avec un
nombre de jobs n
Dans cet exemple, le plus petit job n commence et termine son
exécution en dernier (LPT):
Si ce n'est pas le cas on peut supprimer le job:
LPT ne change pas (pas dernier à terminer)
OPT n'augmente pas (peut diminuer)
Problème identique à n1
n commence son exécution en Cmax (LPT) – pn
Dans l'interval de temps [ 0, Cmax (LPT) – pn] toutes les
machines sont occupées: 1 n−1
Cmax LPT −pn≤ .∑ j=1 p j
Master 2 Informatique 2011
m
10
Preuve LPT
n commence son exécution : Cmax (LPT) – pn
Dans intervalle de temps [ 0, Cmax (LPT) – pn] toutes les
machines sont occupées, les n1 n'ont pas fini de s'exécuter,
1 n−1
sinon on démarre n avant, d'où: Cmax LPT −pn≤ .∑ j=1 p j
m
1 n−1
C max LPT pn . ∑ j=1 p j
m
1 1 n
C max  LPT pn 1−  . ∑ j=1 p j
m m
1
Cmax LPT pn 1− Cmax OPT 
m
Preuve LPT
Cmax LPT pn 1−1/ mCmax OPT 

1
pn (1−
)
C max (LPT ) m
<=> ⩽ +1
C max (OPT ) C max (OPT )
Deux cas :
C max (LPT ) 4 1
alors
Cmax OPT 3.pn ⩽ −
C max (OPT ) 3 3m
Cmax OPT 3.pn

alors au plus deux tâches par machine car n est la plus petite tâche.
attribution de couples de tâches par machines: 1 longue / 1 courte
LPT est optimal : Cmax  LPT  4 1
=1 −
Pire cas pour LPT : borne atteinte ?
m=4
Cmax  LPT  4 1
=1 −
©Schwiegelshohn 07
Cas général Pm || Cmax
LPT suppose temps connus pj
Pas applicable au cas online
Ordonnancement de liste glouton
Cmax  LPT 
Facteur d'approximation maximal: Cmax OPT 
2
Cas Pm || Cmax
Preuve:
1 n
C max (OPT )⩾ . ∑ j=1 p j
et Cmax OPT pj ,∀ j
m
La dernière tâche j a être exécutée, tj début, durée pj
Cmax LPT =t j pj
Avant tj toutes les machines sont occupées, sinon on peut exécuter j
1 n−1
avant : t j  . ∑i=1 pi
m
Cmax LPT t j pj
1 n−1
C max LPT  . ∑i=1 pi p j
m
Cmax LPT Cmax OPT Cmax OPT 2. Cmax OPT 
Cas Pm || Cmax
Algorithme de liste aléatoire :
Cmax  LIST  1
facteur d'approximation 2−
Cmax OPT  m
©Schwiegelshohn 07 ©Schwiegelshohn 07
Schéma d'approximation
Rappel : schéma d'approximation :
Un algorithme A() est schéma d'approximation pour
un problème, si pour toute valeur  et toute instance
I, A() génère une solution réalisable telle que:
C opt (I)−C h (I)
⩽
C opt (I)
Plus contraint qu'une heuristique
Facteur d'approximation démontré
PTAS (Polynomial Time Approximation Scheme) :
temps d'execution polynomial à la taille du problème
avec  > 0
Algorithme :
Trier les tâches par ordre de durée décroissante
soit k, entier fixé
Déterminer, par recherche exhaustive un
ordonnancement optimal pour les k premières tâches
Terminer en attribuant les tâches restantes à la
machine la moins chargée
Exemple :
m = 2, n = 6, k = 4 et (p1 , . . . , p6 ) = (8, 6, 5, 4, 4, 1)
Cas P | pmtn | Cmax
P || Cmax est NP difficile
Introduction de la préemption :
régle de McNaughton : cas statique
D = max { maxj { pj}, (1/m) ∑j pj}
allouer n'importe quel job à la machine 1
si l'exécution dépasse le temps D, préempter et continuer
l'exécution sur la machine 2
allouer tous les jobs en poursuivant la règle
la règle est optimale pour P | pmtn | Cmax
Cas P | pmtn | Cmax
Jj
1 2 3 4 5 6 7 8 9 10
pj 11 10 4 3 2 2 2 1 1 1
0 1 2 3 4 5 6 7 8 9 10 11
1
2 3
3 4 5 6 7
7 8 9 10
Une tâche ne peut pas s'exécuter sur

! deux processeurs simultanément
Cas P | pmtn | Cmax
Preuve :
D est une borne inférieure pour l'ordonnancement
si l'ordonnancement est faisable sur [0, D]
alors optimal
il n'a a pas de recouvrement :
un job ne s'exécute qu'en un seul endroit à un instant donné
car D ≥ max {pj}
il y a assez de capacité dans [0, D] pour placer tous les jobs :
car mD ≥ ∑j pj
donc l'ordonnancement est faisable
Cas P | pmtn, rj | Cmax
Cas online (rj) : modification de l'algorithme de McNaughton
soit J : ensemble des jobs triés par temps d'exécution
décroissants :
si max { pj } ≤ (1/m) ∑j pj alors utiliser la règle de
McNaughton sur J
sinon placer le plus grand job de J sur une machine libre
retirer le job de J, décrémenter m de 1 et aller à 2
Algorithme de HongLeung :
à chaque arrivée de nouveau job, appliquer l'algorithme
modifié sur le nouveau job et ce qui reste à exécuter
l'algorithme est optimal pour P | pmtn, rj | Cmax
Cas P | pmtn, rj | Cmax
J j
1 2 3 4 5 6 7 8 9 10
pj 11 10 4 3 2 2 2 1 1 1 (1/m) ∑j pj == 37 / 4 = 9.25
rj 11 10 4 3 2 2 2 1 1 1
0 1 2 3 4 5 6 7 8 9 10 11
1
2 3
3 4 5 6 7
7 8 9 10
0 1 2 3 4 5 6 7 8 9 10 11
1
2 3
3 4 5 6 7
7 8 9 10
Cas Pm | prec | Cmax
Exemple d'application : multiplication de matrices par Strassen
C = AB
A et B sont découpées en quarts :
Limiter des multiplications car plus coûteuses :
©D. Trystram
©D. Trystram
©D. Trystram
Applications avec précédence
Définition d'un graphe : DAG
G = ( V, E ) / (i,j) ∈ E ⇔ i  j
V : noeuds (vertices) = tâches, valués par le temps d'exec des tâches
E : arrêtes (edges) = communications, valuées par la taille des
données échangées
Problème général est NPComplet :
P | pj=p, intree | Cmax, P | pj=p, outtree | Cmax et P | pmtn, intree | Cmax
ont une solution sans coût de communication
recherche d'heuristiques adaptées
Algorithm de Hu
Cas Pj = p
« Algorithme du chemin critique »
Solution optimale pour : P | pj=p, intree | Cmax et P | pj=p, outtree | Cmax
Définition de niveaux :
Les nœuds sans successeurs sont de niveau 1
Niveau des autres nœuds : L = 1 + max( level of immediate
successors )
Ordonnancement au plus tôt par niveaux décroissants
Complexité : O( nlog(n))
Algorithme de Hu
14
13
15
10
8
7 9 11 12
5
4 6
16
2 3
Algorithme de Hu
14 5
5 13
5 15
10 4
4 8 4 4 4
7 9 4 11 12
5 3
4 3 3 6
2
16
2 2 2 3
1
1
Algorithme de Hu
14 5
5 13
5 15
10 4
4 8 4 4 4
7 9 4 11 12
5 3
4 3 3 6
2 0 1 2 3 4 5 6
16
2 2 2 3 15 12 7 4 2 1
14 10 6 3
1 13 9 5 16
1
11 8
Algorithme de Hu
Preuve :
par induction : h = hauteur de l'arbre ou plus haut niveau
h=1 ou 2 évident
on suppose vrai pour h < k, prouver pour h = k
preuve par l'absurde
Algorithme de Hu
Soit T un intree tel que l'ordo S de Hu n'est pas optimal
Soit  le makespan de S
Soit o le makespan optimal : on a o < 
Puisque S n'est pas optimal :
∃ t, t ≤  2, tel qu'il y ait une machine inoccupée dans
intervalle [t1, t]
[1, ] : racine, une seule tâche
[2, 1] : peut avoir un trou (manque de tâches)
Algorithme de Hu
[t1, t] : k>1, si on a pas de trou du tout c'est
qu'on est optimal, donc d'après l'hypothèse de non
optimalité il y a un trou au moins sur le dernier
(dessin)
puisque T est un intree il doit y avoir une machine
inoccupée dans chaque unité de temps après t.
Il existe une chaîne de jobs de t1 à :
la racine exécutée sur [1, ]
un job de niveau 2 exécuté sur [2, 1]
... jusqu'à t
Algorithme de Hu
Soit T' un intree construit à partir de T en enlevant les jobs de
niveau 2
La hauteur de T' est k1
Le niveau de chaque noeud de T' est le niveau dans T 1
L'ordo S' de Hu est S où la racine est exécutée à 2 : ' = 1
Donc 'o, l'ordonnancement optimal de S' satisfait : 'o ≤ o 1
Or nous avions supposé : o < 
D'où 'o < ' ce qui voudrait dire que S' n'est pas optimal
Algorithme de CoffmanGraham
Cas d'un graphe DAG (pj = p)
Définition de l'ordre lexical:
Soit deux suites décroissantes d'entiers :
N = ( n1, n2, ..., nt)
N' = (n'1, n'2, ..., n't')
avec t < t'
N est lexicalement inférieur à N' ssi :
soit : ∃ k / ni = n'i , ∀i 1 ≤ i < k et nk < n'k
soit : ni = n'i , ∀i 1 ≤ i ≤ t et t < t'
Notation : N < N'
Algorithme :
Pour J, ensemble de jobs, il attribue des labels par ordre
lexicographique
Si k jobs sans successeurs, attribuer les labels 1 à k
pour attribuer le label j > k :
soit J' l'ensemble des jobs dont les successeurs ont déjà un label
 i ∈ J', soit N(i) : séquence décroissante des labels des
successeurs immédiats
attribuer j au job i tel N(i) < N(k) pour tout job k de J'
dès qu'une machine est libre, lui attribuer le jobs prêt de plus
grand label
Optimal pour P2 | Pj=p, prec | Cmax
Revient à :
ordonnancer par niveau,
privilégier les jobs qui ont le plus de dépendances,
placer les jobs sans dépendances dans les temps libres,
bon pour Pm | Pj=p, prec | Cmax
17 18 19
16
15
14
13
10 11
12
6 7
8
1 2 4
3 5
17
19 18 17 19
18
16
16
15 14
15 14 13
13
10 12
11 10 11
12
9
9
6 8 7 7
8 6
2 2 1
1 5 4 3 4
3 5
17 19 18 17 19 2 machines
18
16
16
17 18 16 15 13 12 10 9 7 2
15 14 19 6 1 14 5 11 8 4 3
15 14 13
13 3 machines
11 10 11
10 12 17 16 14 13 12 9 7 2
12 19 6 15 4 10 3
18 8 1 5 11
9
9
4 machines
6 8 7 7 17 16 14 13 12 9 7 2
8 6
19 6 15 10 3
2 2 1 18 8 1 11
1 5 4 3 4
3 5 5 4
Contreexemple
10 11 12
9
8
7
3 6
4 5
2
1
Contreexemple
6 7 10
10 11 11
12
5 9
4 8
7 12
3 6
3 2 8
4 5
2
1 1
9
Contreexemple 2 machines
12 6 3 10 7 4
6 7 10 9 1 11 8 5 2
10 11 11
12
5 9 3 machines
4 8
7 12 12 3 11 7 2 1 3 11 7
6
3 9 1 10 4 9 12 10 3
3 2 8 6 8 2 6 4 8 2
4 5
4 machines
2
1 1 12 3 7
9
9 10 5
6 11 4
1 8 2
Cas Pm | pmtn, prec | Cmax
Si les tâches n'ont pas la même taille : le chemin critique
est une borne minimale
Cas avec préemption :
Pas mieux sauf intree
Algorithme de MuntzCoffman :
optimal pour P | pmtn, intrees | Cmax
Cas Pm | pmtn, prec | Cmax
Algorithme de MuntzCoffman :
définition de niveaux :
temps d'exécution si n'a pas de successeur
temps d'exec + max { niveaux successeurs }
évoluent en fonction du temps
partage des machines en fonction des niveaux :
d'abord aux tâches de plus haut niveau = quantum de 1
Au prorata de ce qui reste : 2 machines / pour 3 tâches =
2/3
au moins une unité de temps
change à chaque fin de job ou quand allocation n'est
plus en rapport avec le niveau
Algorithme MuntzCoffmann
1 2 Jj
1 2 3 4 5 6 7 8 9
pj 1 2 1 3 1 4 1 6 1
3 4
5 6
8
7
5 1 2 6 Jj
1 2 3 4 5 6 7 8 9
pj 1 2 1 3 1 4 1 6 1
4 3 4 6
3
5 6 6
8 7
7
2
9 1
Sur 3 machines
5 1 2 6 J j
1 2 3 4 5 6 7 8 9
pj 1 2 1 3 1 4 1 6 1
4 3 4 6
0 3/2 5/2 10/3 14/3 17/3 20/3 23/3
8 (b=1) 8 (b=1) 1 (b=3/5) 3 (b=3/4) 5 (b=1) 7 (b=1) 9 (b=1)

3
5 6 6
2 (b=2/3) 1 (b=1/2) 2 (b=3/5) 4 (b=3/4) 6 (b=1) 8 (b=1)
8 7 4 (b=2/3) 2 (b=1/2) 4 (b=3/5) 6 (b=3/4) 8 (b=1)
7
2 6 (b=2/3) 4 (b=1/2) 6 (b=3/5) 8 (b=3/4)
9 1
5 1 2 6 J j
1 2 3 4 5 6 7 8 9
pj 1 2 1 3 1 4 1 6 1
4 3 4 6
0 3/2 5/2 10/3 14/3 17/3 20/3 23/3
8 (b=1) 8 (b=1) 1 (b=3/5) 3 (b=3/4) 5 (b=1) 7 (b=1) 9 (b=1)

3
5 6 6
2 (b=2/3) 1 (b=1/2) 2 (b=3/5) 4 (b=3/4) 6 (b=1) 8 (b=1)
8 7 4 (b=2/3) 2 (b=1/2) 4 (b=3/5) 6 (b=3/4) 8 (b=1)
7
2 6 (b=2/3) 4 (b=1/2) 6 (b=3/5) 8 (b=3/4)
9 1
0 1 3/2 2 5/2 3 10/3 4 14/3 17/3 20/3 23/3
8 8 1 2 3 4 5 7 9
2 4 1 2 2 4 6 4 6 6 8
4 6 4 6 6 8 6 8 8
Coûts de communication
Modèles :
UET UCT (Unit Execution Time Unit Communication Time)
quelconques
Nombre de processeurs: P∞ ou Pm
Délais de communication:
fixes
variables: aléatoires, graphe du réseau
modèle 1 port
modèle nport
P |prec, pi=1, cij=1|Cmax
Propriétés :
UET – UCT, Graphe de précédence, Grand nombre de
processeurs
Programme linéaire en nombres entiers :
xij = 0 si les tâches i et j sont sur le même processeur
1 (délais de communication) sinon
Z ensemble des tâches sans prédécesseur
U ensemble des tâches sans successeur
Succ(i) : successeurs de i
Pred(i): prédécesseurs de i
ti : date de début de la tâche i
Programme linéaire :
minimiser Cmax = maxi ∈V (ti + pi)
∀ i ∈ V, ti ≥ 0
∀ i ∈ V, ti + 1 ≤ Cmax
∀ i,j ∈ E, xij ∈ { 0, 1 }
∀ i,j ∈ E, ti + 1 + xij ≤ tj
∀ i ∈ V – U, ∑j ∈ Succ(i) xij ≥ | Succ(i) | 1
∀ i ∈ V – Z, ∑j ∈ Pred(i) xij ≥ | Pred(i) | 1

Programme linéaire :
résolution en nombre entiers complexe
relâcher : xij ∈ {0, 1} pour eij ∈ [0, 1] ⇒ PL polynomial
résoudre le problème:
eij ≥ 0.5 alors xij = 1
eij < 0.5 alors xij = 0
produit un ordonnancement réalisable :
∀ i ∈ V – U, ∑j ∈ Succ(i) eij ≥ | Succ(i) | 1
⇒ au plus 1 eij < 0.5
∀ i ∈ V – Z, ∑j ∈ Pred(i) eij ≥ | Pred(i) | 1
Algorithme d'affectation:
Etape 1: déterminer les dates de début ti
Ai : sousensemble des arcs entrants de i ∈ chemin critique
Si i ∈ Z alors ti = 0
sinon ti =maxj{ tj + pj(=1) + xij} j ∈ Pred(i) et (i,j) ∈ Ai
Etape 2: construction ordonnancement
G' = (V,E') où E' = E\{(i,j) ∈ E | xij=1}
Affecter chacune des composantes connexes sur des machines
différentes en respectant les dates de début
Compétitivité de 4/3
Programme linéaire:
Exemple: t1 ,t2 , ..., t12 ≥ 0
0
1
1
1 t1 ,t2 , ..., t12 + 1 ≤ Cmax
2 2 x1,2,x1,3,x2,4,x2,5, ..., x7,12 ∈ { 0, 1 }
2 3
1 1 1 t1 + 1 +x1,2 ≤ t2
4 1
4 4
4 5 6
4 t1 + 1 + x1,3 ≤ t3 , ..., t7 +1+ x7,12≤ t12
7
1 1 1 1 1
1 x1,2+ x1,3≥ 1, x2,4+ x2,5 ≥ 1, ..., x7,11+ x7,12 ≥ 1
8 9 10 11 12 x2,1 ≥ 0, x3,1 ≥ 0,..., x8,4+ x8,5 ≥ 1, ..., x12,7 ≥ 0
6 6 6 6 6
Solution :
eij= 0,5 , ∀ i,j ∈ E
t1=0, t2=t3=3/2, t4=t5=t6=t7=3, t8=t9=t10=t11=9/2, Cmax= 11/2
Ordonnancement :
Exemple: 0 1 2 3 4 5 6
0 1 4 9
1 2 6 8
1 1
3 5 11
2 2
2 3 7 10
1 1 1 12
4 1
4 4
4 5 4 Solution optimale :
6 7
1 1 1 1 1
1 0 1 2 3 4 5 6
1 3 7 12 11 10
8 9 10 11 12 2 4 5 8
6 6 6 6 6 6 9
Compétivité: 7/6 < 4/3
P |prec, pi=1, cij=1|Cmax
Nombre de processeurs limité
Algorithme de pliage à partir de la solution P
à l'instant t exécuter les tâches Xi dans P
exécuter Xi en ⌈|Xi|/m⌉ unités de temps
0 1 2 3 4 5 6
1 4 9
2 6 8
3 5 11
7 10
12
0 1 2 3 4 5 6 7 8
1 2 4 5 9 11 12
3 6 7 8 10
Compétivité : 1 + 4/3 :
Cmax(m) ≤ ∑i⌈|Xi|/m⌉ => Cmax(m) ≤ ∑i(⌊|Xi|/m⌋+1)
Cmax(m) ≤ ∑i⌊|Xi|/m⌋ + Cmax(∞)
Cmax(m) ≤ ∑i(|Xi|/m) + Cmax(∞)
Cmax(m) ≤ Cmax(opt,m) + Cmax(∞)
Cmax(m) ≤ Cmax(opt,m) + 4/3.Cmax(opt,∞)
Cmax(m) ≤ Cmax(opt,m) + 4/3.Cmax(opt,m)
Cmax(m) ≤ 7/3.Cmax(opt,m)
Amélioration: définir le fils favori i de j : f(i)
ti() = tj() + 1 : s'exécute sur le même processeur
F1: ens. des tâches dont prédécesseurs ont fini leur exécution
 tâche j ordonnancée à t1 :
S(j) ∈ Succ(j) peuvent s'exécuter à t sur même machine
deux tâches de S(j) ne peuvent s'exécuter à t
f(i) ∈ F2 si f(i) ∈ S(j) sinon 1 tâche de S(j) ∈ F2
on choisit un ensemble F' de min{|F1F2|, m} tâches de F1F2
on ordonnance les tâches de F'  F2
Exemple :
0 1 2 3 4 5 6
1 4 9
2 6 8
3 5 11
7 10
12
0 1 2 3 4 5 6 7 8
1 2 4 5 9 11 12
3 6 7 8 10
Cas Pm || ƩCi
Machines identiques
Temps d'exécution équivalents pour les tâches
Solution optimale avec N tâches et M machines
On arrondit : N= k * M, en ajoutant des tâches vides
Ordo équilibré: chaque machine exécute k tâches
Allocation des tâches:
exécute tâche Jp / p1 = m * q + r avec 0 ≤ r < m
en position q+1 sur machine r+1
allocation circulaire par ordre croissant

Mesi Ordo Nmachines PDF

Загружено:

Сведения о документе

Оригинальное название

Авторское право

Доступные форматы

Поделиться этим документом

Поделиться или встроить документ

Параметры публикации

Этот документ был вам полезен?

Это неприемлемый материал?

Авторское право:

Доступные форматы

Mesi Ordo Nmachines PDF

Загружено:

Авторское право:

Доступные форматы

ORDONNANCEMENT

Cmax LPT pn 1−1/ mCmax OPT 

Cmax OPT 3.pn

Une tâche ne peut pas s'exécuter sur

8 (b=1) 8 (b=1) 1 (b=3/5) 3 (b=3/4) 5 (b=1) 7 (b=1) 9 (b=1)

8 (b=1) 8 (b=1) 1 (b=3/5) 3 (b=3/4) 5 (b=1) 7 (b=1) 9 (b=1)

0 1 3/2 2 5/2 3 10/3 4 14/3 17/3 20/3 23/3

Вам также может понравиться