INFO-F-425 Modèles mathématiques et algorithmes pour l ordonnancement. Bernard Fortz

INFO-F-425

Modèles mathématiques et algorithmes pour l’ordonnancement

Bernard Fortz

2008-2009

Table des matières

1 Définition et classification des problèmes d’ordonnancement 2

1.1 Introduction . . . 2

1.2 Données et caractéristiques des tâches . . . 3

1.3 Environnement des machines . . . 4

1.4 Critères d’optimalité . . . 4

1.5 Schéma de classification . . . 5

1.6 Exemples . . . 7

2 Ordonnancement sur une seule machine 9 2.1 Critères minimax . . . 9

2.2 Retard maximum . . . 12

2.3 Flot total pondéré . . . 13

2.4 Nombre pondéré de tâches en retard . . . 16

2.5 Retard pondéré total . . . 18

2.6 Complexité des problèmes sur une machine . . . 20

3 Ordonnancement sur des machines parallèles 21 3.1 Tâches indépendantes . . . 21

3.2 Tâches avec contraintes de précédence . . . 29

3.3 Complexité des problèmes sur machines parallèles . . . 32

4 Problèmes de shop 33 4.1 Le modèle de graphe disjonctif . . . 33

4.2 Problèmes “open shop” . . . 35

4.3 Problèmes “flow shop” . . . 38

4.4 Problèmes “job shop” . . . 39 Référence

– Peter Brucker, Scheduling Algorithms, Springer

1 Définition et classification des problèmes d’ordonnance- ment

1.1 Introduction

Introduction

Définition 1 (Théorie de l’ordonnancement — Wikipedia). La théorie de l’ordonnancement est une branche de la recherche opérationnelle qui s’intéresse au calcul de dates d’exécution optimales de tâches. Pour cela, il est très souvent nécessaire d’affecter en même temps les ressources nécessaires à l’exécution de ces tâches. Un problème d’ordonnancement peut être considéré comme un sous-problème de planification dans lequel il s’agit de décider de l’exé- cution opérationnelle des tâches planifiées.

Définition 2 (Problème d’ordonnancement — Wikipedia). Un problème d’ordonnancement consiste à organiser dans le temps la réalisation de tâches, compte tenu de contraintes tem- porelles (délais, contraintes d’enchaînement) et de contraintes portant sur la disponibilité des ressources requises.

(. . .)

Un ordonnancement constitue une solution au problème d’ordonnancement. Il est défini par le planning d’exécution des tâches (« ordre » et « calendrier ») et d’allocation des ressources et vise à satisfaire un ou plusieurs objectifs. Un ordonnancement est très souvent représenté par un diagramme de Gantt.

Contexte du cours Données

– Ensemble demmachines(ou processeurs)

M_j (j = 1, . . . , m).

– Ensemble dentâches(jobs)

J_i (i= 1, . . . , n).

tâche machine

(production) pièce machine (informatique) programme processeur (hôpital) opération chirurgien (restaurant) repas cuisinier (recherche) projet chercheur

. . . .

Problèmes de base

– Quelle tâche sur quelle machine ? Affectation, allocation des tâches

– Dans quel ordre sur les processeurs ? Séquence par machine

Définition 3(Ordonnancement). Un ordonnancement est une allocation d’un ou plusieurs in- tervalles de temps pour chaque tâche sur une ou plusieurs machines, satisfaisant les contraintes imposées.

Hypothèses

– A chaque instant, un processeur ne peut exécuter qu’une seule tâche.

– A chaque instant, une tâche ne peut être exécutée que par un seul processeur.

Diagrammes de Gantt

Un ordonnancement peut être représenté par undiagramme de Gantt.

Représentation orientée machines

Représentation orientée tâches Diversité des problèmes

Environnement des tâches : paramètres (durée, date de lancement, date limite, . . .), contraintes technologiques (précédences, . . .)

Machines : type, vitesse d’exécution, . . .

Objectif : réaliser une date de fin des tâches, le plus vite possible, . . . Dans le cadre du cours : données et paramètresdéterministes.

1.2 Données et caractéristiques des tâches

Données relatives aux tâches

– Une tâcheJ_i consiste en un nombren_id’opérations(ou tâches élémentaires)O_i1, . . . , O_ini. – Chaque opérationO_ij a untemps d’exécutionp_ij.

– Sin_i = 1, on identifieJ_i etO_i1 et le temps d’exécution est notép_i. – Date de disponibilité(release date)r_i.

– Date échue(due date)d_i. – Poids(priorité)w_i.

Caractéristiques des tâches – Modes d’exécution des tâches :

Sans préemption : une tâche commencée doit être exécutée jusque la fin.

Avec préemption : tâches morcelables, une tâche ou une opération peut être interrompue et recommencée plus tard sur la même machine ou sur une autre.

– Contraintes de précédence :

– J_i ≺J_j, la tâcheJ_idoit être terminée avant de commencerJ_j.

– Ces relations de précédence peuvent être représentées par ungraphe dirigé acyclique.

1.3 Environnement des machines

Types de machines

Machines parallèles : remplissent les mêmes fonctions. 3 formes de machines parallèles : identiques : même vitesse pour toute les tâches (p_ij =p_i pour toute machineM_j) ; uniformes : chaque machineM_j a sa propre vitesse s_j indépendante de la tâche (p_ij =

pi/sj).

générales : la vitesse surM_j dépend de la tâcheJ_i.

Machines dédiées : spécialisées pour l’exécution de certaines tâches.

Quelques configurations intéressantes

Système de machines dédiées, tâchesJ_i composée den_i opérationsO_i1, . . . , O_ini, relations de précédences entre les opérations (general shop).

Job shop :

Oi1 ≺Oi2 ≺ · · · ≺Oini i= 1, . . . , n.

Flow shop : Job shop avec n_i = m pour i = 1, . . . , n, chaque opération est associée à une machine et l’ordre des opérations est le même pour toutes les tâches.

Open shop : Comme le flow shop mais ordre quelconque des opérations.

1.4 Critères d’optimalité

Types de fonctions objectif

Date d’achèvement d’une tâcheJi:Ci. Coût associé : f_i(C_i).

On considère généralement deux types de fonctions objectifs : Objectifs “bottleneck" :

f_max(C) := max{f_i(C_i) :i= 1, . . . , n}

Objectifs additifs :

Xf_i(C) := X

i=1,...,n

f_i(C_i)

Fonctions objectifs classiques Durée totale (makespan) :

C_max= max{C_i :i= 1, . . . , n}

Flot total (total flow time) :

X

i=1,...,n

C_i Flot total pondéré :

X

i=1,...,n

w_iC_i Autres fonctions dépendant des dates limitesd_i:

L_i :=C_i−d_i retard algébrique (lateness) E_i := max{0, d_i−C_i} avance (earliness)

Ti := max{0, Ci−di} retard (tardiness)

D_i :=|C_i−d_i| déviation absolue (absolute deviation) S_i := (C_i−d_i)² déviation au carré (squared deviation) Ui :=

0 siCi ≤di

1 sinon pénalité unitaire (unit penalty) Par exemple,maxTi est le retard maximum,P

iUiest le nombre de tâches en retard, . . .

1.5 Schéma de classification

Schéma de classification

Représentation des classes de problèmes par trois champs : α|β|γ

α: processeurs ; β: paramètres ;

γ : critère d’optimisation.

Processeurs

The first fieldα=α₁α₂ describes the processor environment.

α1 ∈ {∅, P, Q, R, O, F, J}characterizes the type of processor used :

∅: single processor, P : identical processors, Q: uniform processors, R: unrelated processors,

O: dedicated processors : open shop system, F : dedicated processors : flow shop system, J : dedicated processors : job shop system.

Parameterα₂ ∈ {∅, k}denotes the number of processors in the problem :

∅: the number of processors is assumed to be variable,

k: the number of processors is equal tok(kis a positive integer).

Tâches

The second fieldβ =β₁, β₂, β₃, β₄, β₅, β₆, β₇, β₈describes task and resource characteristics.

Parameterβ₁ ∈ {∅, pmtn}indicates the possibility of task preemption : β₁ =∅: no preemption is allowed,

β1 =pmtn: preemptions are allowed.

Parameterβ₂ ∈ {∅, res}characterizes additional resources : β₂ =∅: no additional resources exist,

β₂ =res: there are specified resource constraints.

Parameterβ₃ ∈ {∅, prec, uan, tree, chains}reflects the precedence constraints : β₃ =∅, prec, tree, chains: denotes respectively independent tasks, general

precedence constraints, precedence constraints forming a tree or a set of chains.

Parameterβ₄ ∈ {∅, r_i}describes ready times : β₄ =∅: all ready times are zero,

β₄ =r_i : ready times differ per task.

Parameterβ5 ∈ {∅, pi =p, p ≤pi ≤p}describes task processing times : β₅ =∅: tasks have arbitrary processing times,

β₅ = (p_i =p) : all tasks have processing times equal topunits, β5 = (p≤pi ≤p) : nopiis less thanpor greater thanp.

Parameterβ6 ∈ {∅, d}describes deadlines :

β₆ =∅: no deadlines are assumed in the system

(however, due dates may be defined if a due date involving criterion is used to evaluate schedules),

β₆ =d: deadlines are imposed on the performance of a task set.

Parameterβ₇ ∈ {∅, n_i ≤ k}describes the maximal number of tasks constituting a job in case of job shop systems :

β₇ =∅: the above number is arbitrary or the scheduling problem is not a job shop problem,

β₇ = (n_i ≤k) : the number of tasks for each job is not greater thank.

Parameter β₈ ∈ {∅, no −wait} describes a no-wait property in the case of scheduling on dedicated processors :

β₈ =∅: buffers of unlimited capacity are assumed,

β₈ =no−wait: buffers among processors are of zero capacity and a job after finishing its processing on one processor must im- mediately start on the consecutive processor.

Critère d’optimisation

The third field,γ, denotes an optimality criterion (performance measure), i.e.

γ ∈ {C_max,X

C_i,X

w_iC_i, L_max,X

D_i, . . .}.

1.6 Exemples

7 tâches, duréesp= (6,3,6,2,4,3,1),m= 3machines parallèles.

r = (2,0,1,6,2,1,9) d= (8,3,6,7,9,9,10) pij = ^p_bⁱ

j, b1 = 2, b2 = 1, b3 = 0.5 Précédences :

2 1

3

5 4

6

7

P3|prec|C_max

P1

P2

P3

5 10

T1

T2 T4

T3

T5

T6 T7

C_max = 10(optimal) P3|prec, r_j|C_max

P1

P2

P3

5 10

T2

T1

T4 T6

T3 T5 T7

C_max = 12(optimal)

Q3|prec, r_i|C_max P1

P2

P3

5 10

T2 T1 T4 T6 T7

T3

T5

C_max= 10.5(optimal) P3|prec, ri|Lmax

P1

P2

P3

5 10

T2

T1

T4 T6

T3 T5 T7

L_max= 2,P

U_i = 5

2 Ordonnancement sur une seule machine

2.1 Critères minimax

Remarque préliminaire Sur une seule machine, si – r_i = 0pour touti, et

– la fonction objectif est une fonction monotone des temps d’achèvement,

alors les seuls ordonnancements à considérer sont ceux sans préemption et sans temps morts.

Conséquence du fait que la fonction objectif ne peut être améliorée si la préemption est autori- sée.

1|prec|fmax

f_max = max

j=1,...,nf_j(C_j) f_j monotone pour toutj.

Notations

– N ={1, . . . , n}: ensemble des tâches ; – S ⊆N : tâches non ordonnancées ; – p(S) := P

j∈S

p_j;

– A= (a_ij): matrice d’adjacence des précédences ; – n(i): nombre de successeurs directs dei.

Idées de base de l’algorithme

– Il suffit de construire la séquence optimale des tâches

π := (π(1), π(2), . . . , π(n)). – Construction en arrière.

– Règle : ordonnancer une tâche j ∈ S qui n’a pas de successeur dans S et a une valeur fj(p(S))minimale comme dernière tâche deS.

Algorithme 4(1|prec|f_max- Lawler).

pour (i= 1;i≤n;i++) n(i) =

n

P

j=1

a_ij; S ={1, . . . , n};p=

n

P

j=1

p_j; pour (k =n;k ≥1;k- -){

trouverj ∈Savecn(j)==0etf_j(p)minimum ; S =S\ {j};

π(k) =j; p=p−p_j;

pour (i= 1;i≤n;i++){ si (a_ij == 1)

n(i) = n(i)−1; }

}

Complexité :O(n²) 1|prec;p_j =1;r_j|f_maxet1|prec;pmtn;r_j|f_max

– Sii →j et sir_i+p_i > r_j, alorsj ne peut pas commencer avantr⁰_j =r_i+p_i. On peut donc remplacerr_j parr_j⁰.

– Supposons que les tâches sont triées topologiquement (sii→j, alorsi < j).

Algorithme 5(Modifierr_j).

pour (i= 1;i≤n;i++)

pour (j =i+ 1;j ≤n;j++)

si (i→j)r_j = max{r_j, r_i+p_i} – Sip_i >0eti→j, alorsr⁰_j > r⁰_i.

– Si on ordonnance les tâches en ordre croissant der_j⁰ tel que les dates d’arrivées sont respec- tées, l’ordonnancement est admissible.

– Un tel ordonnancement peut consister en plusieurs blocs. Unblocest un ensemble maximal de tâches exécutées sans temps morts entre elles.

– Supposons que lesr_j ont été modifiés et les tâches ordonnées suivant cesr_j. Algorithme 6(Blocs({1,2, . . . , n})).

i= 1;j = 1; tant que (i≤n){

t =ri;Bj =∅;

tant que (r_i ≤tandi≤n){ B_j =B_j ∪ {i};

t =t+pi; i=i+ 1; C_i =t; }

j =j + 1; }

Pour chaque blocB_j nous définissons :

s_j := min

i∈B_jr_i (temps de début)

p(B_j) := X

i∈Bj

p_i

tj =t(Bj) :=sj +p(Bj) (temps de fin)

1|prec;pmtn;r_j|f_max

Lemme 7. Pour le problème 1|prec;pmtn;r_j|f_max, il existe un ordonnancement optimal tel que les intervalles[s_j, t_j] (j = 1, . . . , k)construits par l’algorithme Blocs sont complètement occupés par des tâches.

Conséquence : les blocs peuvent être traités séparément, la solution étant le maximum des valeurs des solutions sur l’ensemble des blocs.

Considérons un blocB, avecf_max^∗ (B)la valeur optimale pour les tâches deB. Nous avons :

f_max^∗ (B)≥max

j∈B {f_max^∗ (B\ {j})}. De plus,

f_l(t(B)) := min{f_j(t(B)) :j ∈Bsans successeur dansB} ≤f_max^∗ (B).

Construction d’un ordonnancement optimal

– Résoudre le problème pourB\ {l}(la solution a une structure de blocs).

– On peut montrer que l peut être ordonnancé pendant les temps morts de cette structure de blocs.

– L’ordonnancement obtenu a une valeur objectif d’au plus : max{f_max^∗ (B\ {l}), f_l(t(B))}

– Cette valeur est optimale pourB.

Algorithme 8(1|prec;pmtn;r_j|f_max).

S ={1, . . . , n};

f_max^∗ =Decompose(S); Procédure 9(Decompose(S)).

siS =∅renvoyer−∞;

siS ={i}renvoyerf_i(r_i+p_i); sinon{

Blocs(S) ; f =−∞;

pour toutB ∈ {B₁, . . . , B_j} {

trouverltel quef_l(t(B)) := min{f_j(t(B)) :j ∈Bsans successeur dansB};

h=Decompose(B\ {l}) ; f = max{f, h, f_l(t(B))}; }

renvoyerf; }

1|prec;p_j =1;r_j|f_max

– Si les données sont entières, les temps de début et de fin des blocs sont entiers.

– Sip_j = 1pour toutj, alors la préemption n’est pas nécessaire.

– L’algorithme résout donc également1|prec;p_j = 1;r_j|f_max.

– Si l’algorithme est appliqué à1|prec|f_max, il est équivalent à l’algorithme de Lawler.

2.2 Retard maximum

1|r_j|L_max

Théorème 10. 1|r_j|L_maxest NP-difficile.

Mais il existe des cas particuliers polynomiaux...

r_j =rpour toutj Règle de Jackson :

Ordonner les tâches par ordre croissant de date limite (earliest due date (EDD)).

Si précédences : modifier les dates limites (voir plus loin).

dj =dpour toutj

Règle d’ordonnancement :

Ordonner les tâches par ordre croissant de date de disponibilité.

Si précédences : modifier les dates de disponibilité.

p_j = 1pour toutj Règle de Horn (1974) :

A tout moment, ordonner une tâche disponible avec la plus petite date limite.

Si précédences : modifier les dates limites (voir plus loin).

Modification des dates limites

– Sii→j et sidj +pj < di, alorsine peut pas se terminer aprèsd⁰_i =dj +pj. On peut donc remplacerd_i pard⁰_i.

– SoitIP(i)l’ensemble des prédécesseurs directs dei.

Algorithme 11(Modifierd_j).

pour (i= 1;i≤n;i++)n(i) = 0; pour (i= 1;i≤n;i++)

pour tout (j∈IP(i))nj =nj+ 1; F =∅;

pour (i= 1;i≤n;i++) si (ni == 0)F =F∪ {i}; tant que (F 6=∅){

choisirj∈F;

pour tout (i∈IP(j)){ di = min{d_i, dj−pj}; n_i=n_i−1;

si (ni == 0)F =F ∪ {i}; }

F =F\ {j}; }

1|prec;pmtn;r_j|L_max

– Cas particulier de1|prec;pmtn;r_j|f_max. – Résolution directe :

Earliest Due Date

Ordonnancer les tâches en commençant à la plus petite valeur de r_j. A chaque point de décision t donné par une date de disponibilité ou par la fin d’une tâche, ordonnancer une tâchej telle que :

– r_j ≤t;

– tous les prédécesseurs dej sont ordonnancés ; – j a la plus petite date limite modifiée.

1|prec;p_j =1|L_max

– Cas particulier de1|prec;r_j;p_j = 1|f_max. – Résolution plus efficace (Monma 1982).

– Commencer par modifier les dates limites.

– On suppose que toutes les dates limites sont positives (L_max≥0).

– Toutes les tâches sont ordonnancées dans l’intervalle[0, n], ce qui implique qu’aucune tâche j avecd_j ≥nn’est en retard.

– Bucket sorting

B_k :=

{j :d_j =k} if0≤k≤n−1 {j :d_j ≥n} ifk =n.

Algorithme 12(1|prec;p_j = 1|L_max).

pour (k = 0;k≤n;k+ +)Bk =∅; pour (i= 1;i≤n;i++)

si(d_i < n)B_di =B_di ∪ {i}; sinonBn =Bn∪ {i}; i= 1;

pour (k = 0;k≤n;k+ +){ tant que (∃j ∈B_k){

π(i) =j;

B_k=B_K \ {j}; i=i+ 1; }

}

2.3 Flot total pondéré

1|tree|P w_jC_j

– Nous nous intéressons d’abord aux arbres sortants (outtree).

– Pour chaque tâche i, nous définissons : q(i) = ^w_pⁱ

i et soitS(i) l’ensemble des successeurs (pas nécessairement directs) dei, incluanti.

– Pour un ensemble de tâchesI ⊆ {1, . . . , n}: w(I) :=X

i∈I

w_i, p(I) =X

i∈I

p_ietq(I) = w(I) p(I)

– Deux sous-ensemblesI, J ⊆ {1, . . . , n}sontparallèles I ∼ J si, pour tout i ∈ I, j ∈ J, i n’est pas un successeur dej etjn’est pas un successeur dei.

– Chaque ordonnancement est donné par une séquenceπ.

Lemme 13. Soitπune séquence optimale et soientIetJdeux blocs (ensembles de tâches exé- cutées consécutivement), tels queIest ordonnancé immédiatement avantJ. Soitπ⁰la séquence obtenue en échangeantI etJ.

1. I ∼J impliqueq(I)≥q(J).

2. SiI ∼J etq(I) = q(J)alorsπ⁰ est également optimale.

Théorème 14. Soient ietj des tâches telles quei → j etq_j = max{q_k : k ∈ S(i). Alors il existe un ordonnancement optimal dans lequeliest exécuté immédiatement avantj.

– Les conditions du théorème sont satisfaites si nous choisissons une tâchej différente de la racine avec une valeurq_j maximale, et son unique parenti.

– Puisqu’il existe un ordonnancement oùiest exécuté immédiatement avantj, nous pouvons fusionner les noeudsietjet les enfants dejdeviennent enfants dej.

– Le nouveau noeudireprésente la sous-séquenceπ_i :i, j et aura le labelq(i) :=q({i, j}).

– Ce processus peut être appliqué récursivement.

– Notations :

E(i): dernier job deπ_i;

P(i): prédécesseur de i dans la relation de précédence, puis prédécesseur de i dans une séquence optimale.

Algorithme 15(1|outtree|P

w_jC_j).

w(1) =−∞;

pour (i= 1;i≤n;i++)

E(i) =i; J_i ={i}; q(i) =w(i)/p(i); L={1, . . . , n};

tant que (L6={1}){

trouverj ∈Lavec la valeurq(j)la plus grande ; f =P(j);

trouveritel quef ∈J_i; w(i) = w(i) +w(j); p(i) = p(i) +p(j); q(i) =w(i)/p(i); P(j) = E(i); E(i) = E(j); J_i =J_i∪J_j; L=L\ {j}; }

1|intree|P wjCj

Réduction à un problème1|outtree|P

w_j⁰C_j P⁰ : – i→jpourP⁰ ssij →ipourP.

– w_j⁰ =−wj pourj = 1, . . . , n.

FIG. 1 –1|outtree|P w_jC_j

– π: 1, . . . , noptimale pourP ssiπ⁰ :n, . . . ,1optimale pourP⁰. –

f⁰(π⁰) =

n

X

i=1

(−w_i) X

j≥i

p_j

!

=

n

X

i=1

(−w_i) X

j>i

p_j

!

−

n

X

i=1

w_ip_i

=

n

X

i=1

w_i X

j≤i

p_j

!

−

n

X

i=1

w_i

! _n X

j=1

p_j

!

−

n

X

i=1

w_ip_i

=f(π)−a.

1||P w_jC_j

Réduction à un problème1|outtree|P

w_jC_j en ajoutant une raciner avec un temps d’exécu- tion très petit comme tâche artificielle.

Règle du quotient de Smith

Ordonner les tâches en ordre croissant dep_j/w_j (si tous lesw_j >0).

1||P

C_j — Règle de Smith

Ordonner les tâches en ordre croissant dep_j (shortest processing time first).

1|r_j;pmtn|P

C_j — Règle de Smith modifiée

A chaque date de disponibilité ou de fin d’une tâche, ordonnancer une tâche non terminée disponible avec le plus petit temps d’exécution restant.

Remarque :1|rj;pmtn|P

wjCj est NP-difficile.

2.4 Nombre pondéré de tâches en retard

1|rj;pj =1|P wjUj

Nous nous intéressons tout d’abord au problème plus général1|r_j;p_j = 1|P

f_j, avecf_j fonc- tion monotone deC_j pour toutj.

– Si le créneau de tempstest affecté à la tâchei, alors le coût correspondant estfi(t+ 1).

– Puisque lesf_j sont monotones, les tâches devraient être ordonnancées le plus tôt possible.

– Supposons que les tâches sont ordonnées de sorte quer₁ ≤ r₂ ≤ · · · ≤r_n. Les ncréneaux auxquelles les tâches peuvent être ordonnancées au plus tôt peuvent être calculées par : Algorithme 16(Créneaux).

t₁ =r₁;

pour (i= 2;i≤n;i+ +) t_i = max{r_i, . . . , ti−1+ 1};

– Il existe un ordonnancement qui utilise tous les créneaux de tempst_i (i= 1, . . . , n).

– Définissons un graphe biparti complet avec

V₁ = {1, . . . , n}, V₂ = {t₁, . . . , t_n},

ainsi que des coûts

c_ij =

f_i(t_j+ 1) sir_i ≤t_j,

∞ sinon.

– 1|r_j;p_j = 1|P

f_j se réduit à un problème d’affectation dans ce graphe biparti, et peut donc être résolu enO(n³).

1|p_j =1|P w_jU_j

– Algorithme qui construit un ensembleS de tâches à temps.

– Tâches deS ordonnancées en ordre croissant de dates limites.

– Les tâches n’appartenant pas à S sont en retard et peuvent être exécutées dans un ordre arbitraire après les tâches deS.

– Idée de l’algorithme :

– essayer d’ordonnancer les tâches dans l’ordre des dates limites ;

– si la tâche suivanteià ordonnancer est en retard, on ordonnanceiet on retire une tâchek avec la plus petite valeurw_kdeS.

– Nous supposons que1≤d₁ ≤d₂ ≤ · · · ≤d_n. – tindique le temps courant.

Algorithme 17(1|p_j = 1|P

w_jU_j).

t= 1;S =∅;

pour (i= 1;i≤n;i+ +){ si (d_i ≥t)

S =S∪ {i};t=t+ 1; sinon{

retirerkdeSoùkest le plus grand index avecw_kminimal ; S =S∪ {i};

} }

– Complexité :O(nlogn).

– Pour1|p_j = 1|P

U_j, la complexité peut-être réduite àO(n).

1||P Uj

– Construire un ensembleSmaximal de tâches à temps.

– Tâches deS ordonnancées en ordre croissant de dates limites.

– Les tâches n’appartenant pas à S sont en retard et peuvent être exécutées dans un ordre arbitraire après les tâches deS.

– Idée de l’algorithme :

– essayer d’ordonnancer les tâches dans l’ordre des dates limites ;

– si la tâche suivanteià ordonnancer est en retard, on retire une tâchekavec le plus grand temps d’exécution deS.

Algorithme 18(1||P Uj).

t= 0;S =∅;

pour (i= 1;i≤n;i+ +){ S =S∪ {i};

t =t+p_i; si (t > d_i){

trouverj ∈Squi maximisep_j; S =S\ {j};

t =t−p_j; }

}

2.5 Retard pondéré total

1||P w_jT_j – 1||P

T_j est NP-difficile (1||pmtn|P

T_J également).

– 1|r_j;p_j = 1|P

w_jT_j peut être résolu enO(n³)(cas particulier de1|r_j;p_j = 1|P f_j), – mais1|prec;p_j = 1|P

T_j est NP-difficile.

– Algorithme pseudo-polynomial de Lawler pour1||P

w_jT_j si les poidsw_jsont “acceptables”

pour les temps d’exécution p_j, c’est-à-dire si p_i < p_j implique w_i ≥ w_j pour tout i, j = 1, . . . , n.

Lemme 19. Soient des poids arbitraires, et soitπune séquence optimale pour les dates limites d₁, . . . , d_n, et soitC_j le temps de fin de la tâchej,j = 1, . . . , n, pour cette séquence. Soientd⁰_j choisis de sorte que

min{d_j, C_j} ≤d⁰_j ≤max{d_j, C_j}.

Alors toute séquence π⁰ optimale pour les dates limitesd⁰₁, . . . , d⁰_nest aussi optimale par rap- port àd₁, . . . , d_n.

Lemme 20. Supposons que les poidsw_j sont acceptables pour les temps d’exécutionp_j. Alors il existe une séquence optimale π dans laquelle i précède j si d_i ≤ d_j et p_i < p_j, et dans laquelle toutes les tâches à temps sont en ordre croissant de dates limites.

Théorème 21. Soientj = 1, . . . , ndes tâches avecd₁ ≤ d₂ ≤ · · · ≤ d_n et des poids accep- tables. Soitkune tâche avec le plus grand temps d’exécution. Alors il existe une tâchej^∗ ≥k telle que, dans un ordonnancement optimal, toutes les tâches ν = 1, . . . , j^∗ avec ν 6= k sont ordonnancées avantket les tâches restantes sont ordonnancées aprèsk.

– L’algorithme calcule, pour toutj ≥ k, un ordonnancement optimal dans lequel l’ensemble de tâchesI₁ ={1, . . . , j} \ {k}est ordonnancé avantk et l’ensembleI₂ = {j+ 1, . . . , n}

est ordonnancé aprèsk.

– Pour chaquej, le problème est divisé en deux sous-problèmes.

– Dans le premier problème, les tâches deI₁ doivent être ordonnancées optimalement à partir du tempst₁ = 0.

– Dans le deuxième problème, les tâches deI2doivent être ordonnancées optimalement à partir du tempst₂ =

j

P

i=1

p_i.

– Procédure récursive Sequence(t,I) qui calcule un ordonnancement optimal σ^∗ pour l’ensemble de tâchesIen commençant au tempst.

Algorithme 22(Sequence(t, I)).

Si (I =∅)σ^∗ :=∅; Sinon{

Soienti₁ < i₂ <· · ·< i_rles tâches deI; Trouveri_ktel quep_ik = max{p_i :i∈I}; f^∗ =∞;

Pour (j =k+ 1;j ≤r;j+ +){ I₁ ={i_ν : 1≤ν ≤j;ν 6=k};t₁ =t; σ1 =Sequence(t1, I1);

I₂ ={i_ν :j < ν ≤r};t₂ =t+

j

P

ν=1

p_iν; σ₂ =Sequence(t₂, I₂);

σ =σ1 ◦ik◦σ2; Sif(σ, t)< f^∗

σ^∗ =σ;f^∗ =f(σ, t); }

}

Renvoyerσ^∗; Algorithme 23(1||P

w_jT_j).

σ^∗ =Sequence(0,{1, . . . , n});

Complexité :O(n³p)ouO(n⁴p_max)avec p=

n

X

j=1

p_j etp_max =maxⁿ

j=1 p_j.

2.6 Complexité des problèmes sur une machine

Graphe des réductions

Résultats de complexité

http ://www.mathematik.uni-osnabrueck.de/research/OR/class/dateien/classes/ein_ma/ein_ma/

3 Ordonnancement sur des machines parallèles

– P||P

Ci et R||P

Ci sont les seuls problèmes avec des temps d’exécution arbitraires pour lesquels un algorithme polynomial est connu dans le cas où la préemption n’est pas autorisée.

– P2||C_maxetP2||P

w_iC_isont NP-difficiles.

– Nous allons donc principalement étudier des problèmes avec préemption ou des temps d’exé- cution unitaires.

3.1 Tâches indépendantes

Machines identiques

Considéronsn tâchesJ_i avec des temps d’exécution p_i (i = 1, . . . , n)à exécuter sur m ma- chines parallèles identiquesM₁, . . . , M_m.

P|pmtn|C_max

– Une borne inférieure pourP|pmtn|C_maxest donnée par LB := max

( max

i p_i,

n

X

i=1

p_i

! /m

) .

– Un ordonnancement qui atteint cette borne peut être obtenu en un tempsO(n): – Remplir les machines successivement avec les tâches dans un ordre arbitraire.

– Quand la borne est atteinte, diviser la tâche en deux parties et ordonnancer la deuxième partie de la tâche préemptée au temps 0 sur la machine suivante.

– Vu quep_i ≤LB pour touti, les deux parties d’une tâche préemptée ne se chevauchent pas.

Exemple :m = 3

i 1 2 3 4 5 p_i 4 5 3 5 4

0 LB=7

1 2

2 3 4

4 5

P|pmtn;r_i|C_maxetP|pmtn|L_max – Cas particuliers deQ|pmtn;r_i|L_max. – O(nlogn+mn)(voir plus loin).

P|pmtn;r_i|L_max

– Considérons tout d’abord la version “décision” du problème : Etant donné une constanteL, existe-t-il un ordonnancement tel que

maxn

i=1 L_i =maxⁿ

i=1 {C_i−d_i} ≤L?

De plus, nous voulons trouver un tel ordonnancement s’il existe.

– La condition est satisfaite ssi

C_i ≤d^L_i :=L+d_ipour touti= 1, . . . , n.

– Chaque tâcheJ_idoit être exécutée dans l’intervalle[r_i, d^L_i](fenêtres de temps,time windows).

– Nous allons montrer que le problème d’ordonnancer avec préemption n tâches sur m ma- chines identiques de sorte que les tâches sont exécutées pendant leur fenêtre de temps[r_i, d_i] se ramène à un problème de flot maximum.

– Soientt₁ < t₂ <· · ·< t_rla séquence ordonnée des différentes valeurs der_i etd_i. – Considérons les intervalles

I_K := [t_K, t_K+1]de longueurt_K+1−t_K pourK = 1, . . . , r−1.

– Construction du graphe :

Noeuds : Un noeud par tâcheJ_iet par intervalleI_K, plus deux noeuds artificielssett.

Arcs : – (s, J_i)de capacitép_ipour touti= 1, . . . , n.

– (I_K, t)de capacitémT_K pour toutK = 1, . . . , r−1.

– (Ji, IK)siJi peut être exécuté pendantIK (ri ≤tK ettK+1 ≤di), de capacitéTK.

– Il existe un ordonnancement satisfaisant toutes les fenêtres de temps ssi le flot maximum a une valeur

n

P

i=1

p_i. – Complexité :O(n³).

– Pour résoudreP|pmtn;r_i|L_max, recherche par bissection sur la valeur deL.

– Supposons qued_i ≤r_i+nmaxⁿ

j=1 p_j, ce qui implique

−nmaxⁿ

j=1 p_j ≤L_max≤nmaxⁿ

j=1 p_j. – Algorithme en

O(n³(logn+ log1

+ log(maxⁿ

j=1 p_j)) pour résoudre le problème avec une erreur absolue d’au plus. P|p_i =1;r_i|L_max

– On suppose que les tâches sont ordonnées de sorte que r₁ ≤r₂ ≤ · · · ≤r_n.

– r_ientiers : ordonnancer dans l’ordre des dates limitesd_icroissantes.

– Plus précisément : si au temps courant toutes les machines ne sont pas occupées et qu’il y a une tâcheJ_i avecr_i ≤t_i, on ordonnance une telle tâche avec la date limite la plus petite.

– ComplexitéO(nlogn).

Cette approche ne fonctionne pas si lesr_i ne sont pas entiers. Considérons l’exemple suivant avecm= 2.

i 1 2 3 4

r_i 0 0.2 0.5 0.5 d_i 2 3 1.9 3

1 3

2 4

0.2 0.5 1 1.9 2

M1 M2

FIG. 2 – Earliest Due Date —L_max= 0.1

1

0.2 0.5 1 1.9 2

2

3 4

M1 M2

FIG. 3 – Un meilleur ordonnancement —L_max=−0.4

Machines uniformes

– n tâches J_i (i = 1, . . . , n) à ordonnancer sur m machines parallèles uniformes M_j (j = 1, . . . , m).

– Les machines ont desvitessesdifférentess_j (j = 1, . . . , m).

– L’exécution de la tâcheJ_isur la machineM_j durep_i/s_j unités de temps.

– Hypothèses :

1 =s₁ ≥s₂ ≥. . . s_m etp₁ ≥p₂ ≥ · · · ≥p_n. Q|pmtn|C_max

– Soient

P_i =p₁+· · ·+p_ietS_j =s₁+· · ·+s_j pouri= 1, . . . , netj = 1, . . . , m. Nous supposons quen ≥m.

– Condition nécessaire pour exécuter toutes les tâches dans l’intervalle[0, T]: P_n =p₁+· · ·+p_n ≤s₁T +s₂T +· · ·+s_mT =S_mT i.e.Pn/Sm ≤T.

– De même,P_j/S_j ≤T pourj = 1, . . . , m−1, parce queP_j/S_j est une borne inférieure sur le temps nécessaire pour les tâchesJ₁, . . . , J_j.

– On en déduit que

w:= max{max^m−1

j=1 P_j/S_j, P_n/S_m} est une borne inférieure surC_max.

– Nous allons construire un ordonnancement qui atteint cette borne.

– Etant donné un ordonnancement partiel jusqu’au temps t, le niveau p_i(t) de la tâche i au tempstest la portion deipas encore exécutée.

– Au tempst, l’algorithmeniveauappelle la procédureaf f ectation(t)qui associe les tâches aux machines.

– Les machines continuent avec cette affectation de tâches jusqu’à un temps s > t où la procédure est répétée.

Algorithme 24(niveau).

t= 0;

tant qu’il existe une tâcheiavecp_i(t)>0{ af f ectation(t);

t₁ = min{s > t: une tâche se termine au tempss}.

t₂ = min{s > t: il existe deux tâchesi, j telles quep_i(t)> p_j(t)etp_i(s) = p_j(s)}; t = min{t1, t2};

}

Algorithme 25(af f ectation(t)).

J ={i:pi(t)>0};M ={M1, . . . , Mm};

marquer toutes les tâches dansJ et les machines dansM comme non affectées.

tant qu’il existe des tâches et des machines non affectées{

Trouver l’ensembleI ⊆J des tâches avec le plus grand niveau ; r = min{|M|,|J|};

Affecter les tâches deI à exécuter conjointement auxrmachines les plus rapides deM; J =J \I;

Eliminer lesrmachines les plus rapides deM; }

Pour exécuterrtâches1, . . .;rconjointement surM₁, . . . , M_l (r ≥l)pendant une période de tempsT, nous exécutons chaque tâche pendant une période deT /runités de temps sur chaque machine.

– Complexité :O(n²m).

– Amélioré par Gonzalez et Sahni (1978) :O(n+mlogn)et au plus2(m−1)préemptions.

– Conséquence : des tâches 1, . . . , navec des temps d’exécution p₁, . . . , p_n peuvent être or- donnancées dans un intervalle de longueurT ssi

X

i∈A

p_i ≤T h(A)pour toutA⊆ {1, . . . , n}

avec

h(A) =

S_|A| si|A| ≤m S_m sinon.

FIG. 4 – Algorithme niveau Q|pmtn;r_i|L_max

– A nouveau, nous considérons d’abord le problème de trouver un ordonnancement avec pré- emption tel que chaque tâcheJi est exécutée dans sa fenêtres de temps[ri, di].

– Nous allons montrer que le problème se ramène à un problème de flot.

– Soientt₁ < t₂ <· · ·< t_rla séquence ordonnée des différentes valeurs der_i etd_i. – Considérons les intervalles

I_K := [t_K, t_K+1]de longueurt_K+1−t_K pourK = 1, . . . , r−1.

– Rappel : Construction du graphe pour le problème avec des machines identiques : Noeuds : Un noeud par tâcheJ_iet par intervalleI_K, plus deux noeuds artificielssett.

Arcs : – (s, Ji)de capacitépipour touti= 1, . . . , n.

– (I_K, t)de capacitémT_K pour toutK = 1, . . . , r−1.

– (J_i, I_K)siJ_i peut être exécuté pendantI_K (r_i ≤t_K ett_K+1 ≤d_i), de capacitéT_K. – Nous étendons ce graphe de la manière suivante : soit I_K un intervalle arbitraire et soient

J_i1, . . . , J_is les prédécesseurs du noeudI_K.

– Nous remplaçons le sous-graphe défini parI_K, J_i1, . . . , J_is par un graphe étendu avec : – des noeud additionnels(K,1),(K,2), . . . ,(K, m);

– pourj = 1, . . . , m, un arc de(K, j)àI_K de capacitéj(s_j−s_j+1)T_K;

– pourν = 1, . . . , setj = 1, . . . , m, un arc deJ_iν à(K, j)de capacité(s_j −s_j+1)T_K.¹

1Nous posonssm+1= 0.

FIG. 5 –Q|pmtn;ri|Lmax- Problème de flot Théorème 26. Les deux propriétés suivantes sont équivalentes :

1. Il existe un ordonnancement admissible.

2. Dans le réseau étendu il existe un flot desàtde valeur

n

P

i=1

p_i. Complexité :O(mn³)

– Pour résoudreQ|pmtn;r_i|L_max, recherche par bissection sur la valeur deL.

– Algorithme en

O(mn³(logn+ log1

+ log(maxⁿ

j=1 p_j)) pour résoudre le problème avec une erreur absolue d’au plus. Q||P

C_i

– Soiti₁, i₂, . . . , i_rla séquence des tâches exécutées sur la machineM_j. La contribution de ces tâches dans la fonction objectif est

p_i1 r

s_j +p_i2r−1

s_j +· · ·+p_ir 1 s_j.

– On en déduit que dans un ordonnancement optimal, les tâches de la machineM_j doivent être ordonnancées en ordre croissant de temps d’exécution.

– Distribution optimale des tâches sur les machines :t1, . . . , tnséquence croissante des nombres de l’ensemble

n1 s1,_s¹

2, . . . ,_s¹

m,_s²

1,_s²

2, . . . ,_s²

m,_s³

1, . . .o . – Sit_i = _s^k

j, ordonnancer la tâcheisurM_j commek-ème dernière tâche (en supposantp₁ ≥ p₂ ≥ · · · ≥p_n).

Algorithme 27(Q||P C_i).

pour (j = 1;j ≤m;j+ +) π_j =∅;w_j = _s¹

j ; pour (i= 1;i≤n;i+ +){

– Trouver le plus grandj tel quew_j := min^m_ν=1w_ν; – π_j =i◦π_j;

– w_j =w_j+ _s¹

j; }

Q|pmtn|P C_i

– Version adaptée de SPT (Shortest Processing Time first).

– Ordonner les tâches en ordre croissant de temps d’exécution, et ordonnancer chaque tâche successive avec préemption pour minimiser son temps de fin.

Algorithme 28. Q|pmtn|P C_i a= 0;

tant que (p₁ >0) {

– Trouver le plus grandiavecp_i >0; – ∆t=pi/s1;

– pour (ν =i;ν≥max{1, i−m+ 1};ν− −){ OrdonnancerνsurM1+i−ν pendant[a, a+ ∆t]; pν =pν −∆t s1+i−ν;

}

a =a+ ∆t; }

Q|p_i =1|P

f_ietQ|p_i =1|f_max

– Il existe un ordonnancement optimal dans lequel les tâches sont exécutées dans des périodes de temps avec lesndates de fin possibles au plus tôt.

– Génération : initialiser unheapavec des temps de fin1/s_j (j = 1, . . . , m). A chaque étape, retirer le plus petit élément du heap ; si le temps de fin estk/s_j, insérer(k+ 1)/s_j.

– Solution deQ|p_i = 1|P

f_i : problème d’affectation.

– Solution deQ|p_i = 1|f_max: modification de l’algorithme de Lawler.

Machines indépendantes

– ntâchesJ_i(i= 1, . . . , n)à ordonnancer surmmachines parallèles indépendantesM_j (j = 1, . . . , m).

– L’exécution de la tâcheJ_isur la machineM_j durep_ij unités de temps.

R||P C_i

– Réduction à un problème d’affectation.

– Soiti₁, i₂, . . . , i_rla séquence des tâches exécutées sur la machineM_j. La contribution de ces tâches dans la fonction objectif est

rp_i1j+ (r−1)p_i2j +· · ·+ 1p_irj.

– Nous définissons la position d’une tâche sur une machine en les considérant en partant de la dernière tâche exécutée.

– Pour résoudre le problème, on affecte de manière optimale les tâchesj aux positionsk sur les machinesj. Le coût pour associerià(k, j)estkp_ij.

– Remarquons que siiest affecté à la position k > 1sur la machine j, alors il y a aussi une tâche en positionk−1surj.

R|pmtn|C_max – 2 étapes :

1. Programme linéaire pour calculer pour chaque tâcheiet chaque machinejle tempst_ij passé par la machinej sur la tâcheidans un ordonnancement optimal.

2. Calcul de l’ordonnancement correspondant.

– Soitt_ij le temps d’exécution de la partie de la tâcheieffectuée sur la machinej. L’équation

m

X

j=1

t_ij p_ij = 1 doit être satisfaite pour toute tâchei= 1, . . . , nterminée.

min C_max s.c.

m

X

j=1

tij

p_ij = 1 i= 1, . . . , n

m

X

j=1

t_ij ≤C_max i= 1, . . . , n

n

X

i=1

t_ij ≤C_max j = 1, . . . , m

t_ij ≥0 i= 1, . . . , n, j = 1, . . . , m.

– Pour un ordonnancement optimal nous avons : C_max= max

( maxn

i=1 m

X

j=1

t_ij,max^m

j=1 n

X

i=1

t_ij )

.

– Réalisation de l’ordonnancement : couplage biparti (voir Brucker, Section 2.4).

R|pmtn|L_max

– Approche similaire.

– Supposons que les tâches sont ordonnées de sorte que d₁ ≤d₂ ≤ · · · ≤d_n.

– Soitt⁽¹⁾_ij le temps d’exécution de la tâcheisur la machinejpendant l’intervalleI₁ = [0, d₁+ L_max], et, pourk = 2, . . . , n, soit t^(k)_ij le temps d’exécution de la tâche isur la machine j pendant l’intervalleI_k = [dk−1+L_max, d_k+L_max].

min L_max

s.c.

m

X

j=1 n

X

k=1

t^(k)_ij

p_ij = 1 i= 1, . . . , n

m

X

j=1

t⁽¹⁾_ij ≤d₁+L_max i= 1, . . . , n

m

X

j=1

t^(k)_ij ≤d_k−dk−1 i=k, . . . , n, k= 2, . . . , n

n

X

i=1

t⁽¹⁾_ij ≤d₁+L_max j = 1, . . . , m

n

X

i=1

t^(k)_ij ≤d_k−d_k−1 j = 1, . . . , m, k= 2, . . . , n t^(k)_ij ≥0 i, k = 1, . . . , n, j = 1, . . . , m.

3.2 Tâches avec contraintes de précédence

– Nous considérons maintenant n tâches i = 1, . . . , n avec des contraintes de précédences entre elles.

– Notations :i →j sij successeur direct dei,IP(i)ensemble des prédécesseurs directs dei etIS(i)ensemble des successeurs directs dei.

IP(i) = {j :j →i} IS(i) ={j :i→j}.

– Arbre entrant : un seul successeurs(i). Arbre sortant : un seul prédécesseurp(i).

– Dates de disponibilités cohérentes avec les contraintes de précédence siri+pi ≤ rj quand i → j. Dates limites cohérentes avec les contraintes de précédence si d_i ≤ d_j −p_j quand i→j.

P|intree;p_i=1|L_max – 2 étapes :

1. Modification des dates limites.

2. Ordonnancement en ordre croissant de dates limites.

– Modification des dates limites : remplacerd_iparmin{d_i, d_j −1}quandi→j.

Algorithme 29(Modification des dates limites).

T ={i:in’a pas de successeur}; tant que (T 6=∅){

choisiri∈T ;

pour toutj ∈IP(i){ – d_j = min{d_j, d_i −1}; – T =T ∪ {j};

}

T =T \ {i}; }

– Tâches ordonnées avecd⁰₁ ≤d⁰₂ ≤ · · · ≤d⁰_n.

– F : temps au plus tôt où une machine est disponible. r(i): dernier temps de fin d’un pré- décesseur de i. n(t) : nombre de tâches ordonnancées au tempst. x(i): début de la tâche i.

Algorithme 30(P|intree;p_i = 1|L_max).

F = 0 ;

pour (i= 1;i≤n;i+ +)r(i) = 0; pour (t= 0;t ≤n;i+ +)n(t) = 0; pour (i= 1;i≤n;i+ +){

t = max{r(i), F}; x(i) = t;

n(t) = n(t) + 1;

si (n(t) ==m)F =t+ 1; j =s(i);

r(j) = max{r(j), t+ 1}; }

P|outtree;p_i = 1;r_i|C_max: symétrique àP|intree;p_i = 1|L_max. P|intree;p_i = 1|C_max: symétrique àP|outtree;p_i = 1|C_max. P|tree;p_i = 1|C_max peut donc être résolu enO(n).

P|outtree;p_i = 1|L_max est NP-difficile.

P₂|prec;p_i=1;L_max

– A nouveau, calcul de dates limites modifiées, mais procédure plus sophistiquée.

– SoitS(i)l’ensemble des successeurs (pas nécessairement immédiats) de i. Supposons que les dates modifiée ont été calculées pour toutj ∈ S(i). Nous définissons pour tout réeldet toute tâchei

g(i, d) =|{k :k ∈S(i), d⁰_k ≤d}|.

– Sij ∈S(i)et si tous les successeurs deidoivent être finis avant leur date limite, alorsidoit être terminé avant

d⁰_j −

g(i, d⁰_j) 2

. – On peut donc définird⁰_i par

d⁰_i = min

d_i,min{d⁰_j −

g(i, d⁰_j) 2

:j ∈S(i)

.

Algorithme 31(Modification des dates limites 2).

pour (i= 1;i≤n;i+ +)n(i) =Pn j=1a_ij; calculerL, liste des tâches en ordre croissant ded_i; S ={1, . . . , n};

tant que (S 6=∅){

Trouveri∈Savecn(i) = 0; count= 1;

pour (j = 1;j ≤n;j+ +) si (k :=L(j)∈S(i)){ d_i = min{d_i, d_k−_count

2

; count+ +;

}

éliminerideLet inséreriavec sa valeur actuelled_i; pour (j = 1;j ≤n;j+ +) si (a_ij == 1)n(j)− −; S =S\ {j};

}

Algorithme 32(P₂|prec;p_i = 1;L_max).

pour (j = 1;j ≤n;j + +)v(j) =Pn i=1a_ij; T = 0;M =∅;

tant que (L6=∅){

si (|M|== 2) ou (il n’y a pas de tâche dansLavecv(j) == 0){ T =T + 1;

tant qu’il existei∈M {

pour (j = 1;j ≤n;j+ +) si (a_ij == 1)v(j) = v(j)−1; M =M \ {i};

} }

trouver la première tâchej ∈Lavecv(j) == 0; x(j) =T ;

M =M ∪ {j}; L=L\ {j};}

3.3 Complexité des problèmes sur machines parallèles

Graphe des réductions

Résultats de complexité – Problèmes sans préemption :

http ://www.mathematik.uni-osnabrueck.de/research/OR/class/dateien/classes/pqr_nop/pqr_nop – Problèmes avec préemption :

http ://www.mathematik.uni-osnabrueck.de/research/OR/class/dateien/classes/pqr_pmt/pqr_pmt

4 Problèmes de shop

4.1 Le modèle de graphe disjonctif

Problèmes étudiés

Système de machines dédiées, tâchesJ_i composée den_i opérationsO_i1, . . . , O_ini, relations de précédences entre les opérations (general shop).

Job shop :

O_i1 ≺O_i2 ≺ · · · ≺O_ini i= 1, . . . , n.

Flow shop : Job shop avec ni = m pour i = 1, . . . , n, chaque opération est associée à une machine et l’ordre des opérations est le même pour toutes les tâches.

Open shop : Comme le flow shop mais ordre quelconque des opérations.

Ces problèmes sont très utilisés pour modéliser les processus de production industrielle.

Graphes disjonctifs

– Il est possible de représenter certains ordonnancements admissibles pour les problèmes de shop par des graphes disjonctifs.

– Si la fonction objectif est régulière, l’ensemble des solutions admissibles représentées de cette façon contient toujours une solution optimale.

Pour une instance d’un problème de shop général, legraphe disjonctifG= (V, C, D)est défini comme suit :

V est l’ensemble des noeuds représentant les opérations de toutes les tâches. Deux noeuds additionnels : source0 ∈ V et puits∗ ∈ V. Un poids est associé à chaque noeud, qui est nul pour0et ∗et égal au temps d’exécution de l’opération correspondante pour les autres noeuds.

C est l’ensemble desarcs conjonctifsdirigés. Ces arcs représentent les relation de précédence entre les opérations. Il y a également des arcs conjonctifs entre la source et toutes les opérations sans prédécesseur, et entre les opérations sans successeur et le puits.

D est l’ensemble desarcs disjonctifsnon dirigés. Un tel arc existe pour chaque paire d’opéra- tions appartenant à la même tâche qui ne sont pas connectées par un arc conjonctif et pour chaque paire d’opérations à effectuer sur la même machine qui ne sont pas connectées par un arc conjonctif.

Un exemple avec 4 tâches et 4 machines :

– Décision d’ordonnancement : définir un ordre des opérations connectées par des arcs dis- jonctifs.

– Transformer les arcs non dirigés en arcs dirigés.

– Unesélection S est un ensemble d’arcs disjonctifs dirigés. Les arcs disjonctifs qui ont été dirigés sont appelés arcsfixés.

– Une sélection estcomplètesi

– tous les arcs disjonctifs sont fixés et

– le graphe résultantG(S) = (V, C∪S)est acyclique.

Une sélection complète pour l’exemple précédent :

Construction de l’ordonnancementx= (x_i), défini par les temps de début de chaque opération i, pour une sélection complète donnée :