Vous êtes sur la page 1sur 162

Université de Technologie de Troyes

THESE PRESENTEE POUR L’OBTENTION DU GRADE DE


DOCTEUR DE L’UNIVERSITE DE TECHNOLOGIE DE TROYES
Spécialité : Optimisation et Sûreté des Systèmes

Par :
Ahmed Saâdeddine SOUISSI

ORDONNANCEMENT AVEC PRISE EN COMPTE


DES INDISPONIBILITES DEPENDANTES ET
INDEPENDANTES

SOUTENUE PUBLIQUEMENT LE 7 NOVEMBRE 2005

MEMBRES DE JURY :
M. Philippe CHRETIENNE Professeur à l’ Université de Paris 6, Examinateur, Président
M. Chengbin CHU Professeur à Université de Technologie de Troyes, Directeur
M. Michel GOURGAND Professeur à l'Université Blaise Pascal, Rapporteur
M. Mohamed HAOUARI Professeur à l’Ecole Polytechnique de Tunisie, Rapporteur
M. Imed KACEM MCF à l’Université de Technologie de Troyes, Directeur
M. Pierre LOPEZ Chargé de recherche au LASS-CNRS Toulouse, Examinateur

N° attribué par la bibliothèque |2|0|0|5|T|R|O|Y|0|0|1|0|


à tous mes proches

2
Table des matières

Introduction
1 Introduction sur l’ordonnancement 11
1.1 Présentation des problèmes d’ordonnancement . . . . . . . . . . . . . . . . . . . . 11
1.1.1 Définition . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 11
1.1.2 Classification des problèmes d’ordonnancement . . . . . . . . . . . . . . . 13

1.2 Complexité des problèmes d’ordonnancement . . . . . . . . . . . . . . . . . . . . . 17


1.2.1 Complexité des algorithmes . . . . . . . . . . . . . . . . . . . . . . . . . . 17
1.2.2 Complexité des problèmes . . . . . . . . . . . . . . . . . . . . . . . . . . . 18
1.3 Méthodes de résolution . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 20
1.3.1 Méthodes exactes . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 21
1.3.2 Méthodes approchées . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 25
1.4 Présentation du contexte abordé . . . . . . . . . . . . . . . . . . . . . . . . . . . . 31
1.5 Conclusion . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 32
2 Ordonnancement avec prise en compte des temps de préparation : étude de
1|Si,j | Ti 33
2.1 Introduction . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 33
2.2 Survol bibliographique . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 35
2.3 Etude du problème 1 S | T .. .. ... .. .. ..
i,j | i . . . . . . . . . . . . . . . . 41
2.3.1 Minimisation du retard total sur une machine . . . . . . . . . . . . . . . . 41
2.3.2 Problématique . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 42

3
2.3.3 Résolution par approche de séparation et d’évaluation . . . . . . . . . . . . 43
2.3.4 Bornes inférieures . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 43
2.3.5 Propriétés de dominance . . . . . . . . . . . . . . . . . . . . . . . . . . . . 47
2.3.6 Heuristiques . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 50
2.3.7 Résultats expérimentaux . . . . . . . . . . . . . . . . . . . . . . . . . . . . 52
2.4 Conclusion . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 58
3 Autres applications du problème 1 S | i,j | Ti 62
3.1 Etude du problème 1 S | C .......
i,j | i ...................... 62
3.1.1 Problématique . . . . . . . . . . . . ...................... 64
3.1.2 Description de la méthode proposée ...................... 64
70
3.2 Etude du problème P S |T ......
i,j | i . . . . . . . . . . . . . . . . . . . . . . 71
3.2.1 Rappel bibliographique . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 72
3.2.2 Formulation du problème . . . . . . . . . . . . . . . . . . . . . . . . . . . . 73
3.2.3 Description de la méthode proposée . . . . . . . . . . . . . . . . . . . . . . 75
3.2.4 Bornes inférieures . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 76
3.2.5 Heuristiques . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 79
3.2.6 Résultats expérimentaux . . . . . . . . . . . . . . . . . . . . . . . . . . . . 80
3.3 Conclusion générale . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 82

4 Etude du problème 1 , h1 || wi Ci 92

4.1 Introduction . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 92
4.2 Problèmes d’ordonnacement avec contrainte d’indisponibilité de machine . . . . . 93
4.2.1 Cas d’une seule machine . . . . . . . . . . . . . . . . . . . . . . . . . . . . 93
4.2.2 Cas d’ateliers . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 96
4.3 Etude du problème 1 1 w C . . . . . . . . . . . . . . . . . . . . . .
, h || i i . . . . . 97
4.3.1 Problématique . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 97
4.3.2 Bornes inférieures et propriétés . . . . . . . . . . . . . . . . . . . . . . . . 97
4.3.3 Bornes inférieures basées sur le splitting [86] . . . . . . . . . . . . . . . . . 105
4
4.3.4 Approches exactes pour le problème 1 1 , h || . . . . . . . . . . . . . . 108
wi Ci

4.3.5 Résultats expérimentaux . . . . . . . . . . . . . . . . . . . . . . . . . . . . 110


4.3.6 Etude expérimentale de la borne 4 et de la borne linéaire . . . . . . . . 112
LB

4.3.7 Comparaison de la branch and bound et de la programmation dynamique . 112


4.4 Conclusion . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 114
5 Etude du problème 1 r Cmax
, h1 | i | 127

5.1 Formulation du problème . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 127


5.2 Propriétés et analyse préliminaire . . . . . . . . . . . . . . . . . . . . . . . . . . . 128
5.3 Trois méthodes exactes . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 132
5.3.1 Procédure de séparation et d’évaluation (PSE) . . . . . . . . . . . . . . . . 132
5.3.2 Programmation linéaire en nombres entiers (PLNE) . . . . . . . . . . . . . 133
5.3.3 Programmation dynamique . . . . . . . . . . . . . . . . . . . . . . . . . . 133
5.4 Etude expérimentale . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 134
5.4.1 Comparaison de la borne linéaire avec la borne LB1 . . . . . . . . . . . . . 135
5.4.2 Comparaison entre la branch and bound et la programmation dynamique . 136
5.5 Conclusion . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 137
Conclusion générale

Bibliographie 144

5
Table des figures

1-1 Schéma de la procédure de séparation et d’évaluation . . . . . . . . . . . . . . . . 23


1-2 Méthode de descente . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 28
1-3 Algorithme de la méthode de la descente . . . . . . . . . . . . . . . . . . . . . . . 28
1-4 Algorithme de la recherche tabou . . . . . . . . . . . . . . . . . . . . . . . . . . . 29
1-5 Algorithme du recuit simulé . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 29
2-1 Les problèmes d’ordonancement avec prise en compte de temps de préparation . . 37
2-2 La séquence partielle Q . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 44
2-3 Définition de p . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
i
. . 45
2-4 Définition de q . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
i . . 47
2-5 Illustration de la règle de dominance de Ragatz . . . . . . . . . . . . . . . . . . . 48
2-6 Application de la règle de dominance de Ragatz . . . . . . . . . . . . . . . . . . . 49
2-7 Séquences partielles S et S . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 50
2-8 Séquences S et S . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 51
2-9 Comparaison des nombres des noeuds . . . . . . . . . . . . . . . . . . . . . . . . . 58
2-10 Comparaison des temps de calcul . . . . . . . . . . . . . . . . . . . . . . . . . . . 58
3-1 Séquences partielles S et S . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 67
3-2 Règle APRTF . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 69
3-3 Séquence suivant la règle PRTF . . . . . . . . . . . . . . . . . . . . . . . . . . . . 69
3-4 Définition de la séquence Q . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 74
3-5 La séquence partielle Q . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 76
3-6 Définition de rΦ( k) . . . . . . .
l . . . . . . . . . . . . . . . . . . . . . . . . . . . . 78

6
3-7 Comparaison des valeurs moyennes du retard total pour deux machines parallèles 81
3-8 Comparaison des valeurs moyennes du retard total pour trois machines parallèles . 82
3-9 Comparaison des valeurs moyennes du retard total pour quatre machines . . . . . 83
3-10 Comparaison des valeurs moyennes du retard total pour cinq machines parallèles . 83
3-11 Comparaison des valeurs moyennes du retard total pour dix machines parallèles . 88
3-12 Comparaison des valeurs moyennes du nombre des noeuds pour deux machines . . 88
3-13 Comparaison des valeurs moyennes du temps de calcul pour deux machines . . . . 89
3-14 Comparaison des valeurs moyennes du nombre des noeuds pour trois machines . . 89
3-15 Comparaison des valeurs moyennes du temps de calcul pour trois machines . . . . 90
3-16 Comparaison des valeurs moyennes du nombre des noeuds pour quatre machines . 90
3-17 Comparaison des valeurs moyennes du temps de calcul pour quatre machines . . . 91
4-1 Illustration de la règle WSRPT . . . . . . . .... . . . . . . . . . . . . . . . . . 98
4-2 Illustration des règles WSPT et WSRPT . . .... . . . . . . . . . . . . . . . . . 99
4-3 ......................... .... . . . . . . . . . . . . . . . . . 99
4-4 Illustration de calcul de LB2 pour w = wk+1
t ·
δT
pk+1
. . . . . . . . . . . . . . . . . . 100
4-5 Comparaison de LB1 et LB2∗ . . . . . . . . . .... . . . . . . . . . . . . . . . . . 102
4-6 Calcul de LB2 pour w = 0 . . . . . . . . . .
t .... . . . . . . . . . . . . . . . . . 102
4-7 Calcul de LB2 pour w = 32 . . . . . . . . . .
t .... . . . . . . . . . . . . . . . . . 103
4-8 Calcul de LB2 pour w = 2 . . . . . . . . . .
t .... . . . . . . . . . . . . . . . . . 103
4-9 Calcul de LB2 pour w = 3 . . . . . . . . . .
t .... . . . . . . . . . . . . . . . . . 103
4-10 Calcul de LB2 pour w = 92 . . . . . . . . . .
t .... . . . . . . . . . . . . . . . . . 104
4-11 Calcul de LB2 pour w = 12 . . . . . . . . .
t .... . . . . . . . . . . . . . . . . . 104
4-12 La variation de LB2 en fonction de wt . . . .... . . . . . . . . . . . . . . . . . 104
4-13 Illustration de calcul de LB1 . . . . . . . . . .... . . . . . . . . . . . . . . . . . 105
4-14 Découpage appliqué pour la borne LB3 . . . .... . . . . . . . . . . . . . . . . . 106
4-15 Comparaison de LB2∗ et LB3 . . . . . . . . . .... . . . . . . . . . . . . . . . . . 107
4-16 Comparaison de différentes méthodes . . . . .... . . . . . . . . . . . . . . . . . 112
4-17 Comparaison de LB4 et de LBLP . . . . . . .... . . . . . . . . . . . . . . . . . 113

7
4-18 Temps de calcul pour la branch and bound et pour la programmation dynamique :
4ème série . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 114

5-1 Illustration de la notion du bloc . . . . . . . . . . . . . . . . . . . . . . . . . . . . 128


5-2 Solution donnée par F IF O . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 131
5-3 Solution optimale . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 131
5-4 Définition de δ . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 132
5-5 Comparaison des temps de calcul des trois méthodes . . . . . . . . . . . . . . . . 135
5-6 Comparaison des ratios des bornes inférieures . . . . . . . . . . . . . . . . . . . . 136
5-7 Comparaison des temps de calcul pour la B&B et la PD . . . . . . . . . . . . . . 137

8
Liste des tableaux

2.1 Résultats obtenus en utilisant la borne inférieure de Ragatz pour la série 1 . . . . 53


2.2 Résultats obtenus en utilisant la nouvelle borne inférieure pour la série 1 . . . . . 54
2.3 Résultats obtenus en utilisant les deux bornes inférieures pour la série 1 . . . . . . 54
2.4 Résultats obtenus en utilisant la borne inférieure de Ragatz pour la série 2 . . . . 54
2.5 Résultats obtenus en utilisant la nouvelle borne inférieure pour la série 2 . . . . . 55
2.6 Résultats obtenus en utilisant les deux bornes inférieures pour la série 2 . . . . . . 55
2.7 Résultats obtenus en utilisant la borne inférieure de Ragatz pour la série 3 . . . . 55
2.8 Résultats obtenus en utilisant la nouvelle borne inférieure pour la série 3 . . . . . 56
2.9 Résultats obtenus en utilisant les deux bornes inférieures pour la série 3 . . . . . . 56
2.10 Résultats en moyenne obtenus : stratégies 1 et 2 . . . . . . . . . . . . . . . . . . . 60
2.11 Résultats en moyenne obtenus : stratégies 3 et 4 . . . . . . . . . . . . . . . . . . . 61
3.1 Résultats moyens obtenus pour les stratégies 1 et 2 . . . . . . . . . . . . . . . . . 84
3.2 Résultats moyens obtenus pour les stratégies 3 et 4 . . . . . . . . . . . . . . . . . 85
3.3 Résultats obtenus pour deux machines (retard total) . . . . . . . . . . . . . . . . 86
3.4 Résultats obtenus pour trois machines (retard total) . . . . . . . . . . . . . . . . . 86
3.5 Résultats obtenus pour quatre machines (retard total) . . . . . . . . . . . . . . . . 87
3.6 Résultats obtenus pour cinq machines (retard total) . . . . . . . . . . . . . . . . . 87
3.7 Résultats obtenus pour 10 machines . . . . . . . . . . . . . . . . . . . . . . . . . . 87
4.1 Cas de deux machines parallèles . . . . . . . . . . . . . . . . . . . . . . . . . . . . 96
4.2 Cas de m machines paralèlles (m > 2) . . . . . . . . . . . . . . . . . . . . . . . . . 115
4.3 Cas d’open-shop . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 115

9
4.4 Cas de flow-shop . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .... 116
4.5 Tableau des données . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .... 116
4.6 Table des valeurs de la fonction LB2 . . . . . . . . . . . . . . . . . . . . . .... 117
4.7 Résultats obtenus pour la programmation linéaire : Série 1 . . . . . . . . . .... 117
4.8 Résultats obtenus pour la programmation linéaire : Série 2 . . . . . . . . . .... 118
4.9 Résultats obtenus pour la programmation linéaire : Série 3 . . . . . . . . . .... 118
4.10 Résultats obtenus pour la branch and bound : Série 1 . . . . . . . . . . . . .... 119
4.11 Résultats obtenus pour la branch and bound : Série 2 . . . . . . . . . . . . .... 120
4.12 Résultats obtenus pour la branch and bound : Série 3 . . . . . . . . . . . . .... 121
4.13 Résultats obtenus pour la programmation dynamique : Série 1 . . . . . . . .... 122
4.14 Résultats obtenus pour la programmation dynamique : Série 2 . . . . . . . .... 123
4.15 Résultats obtenus pour la programmation dynamique : Série 3 . . . . . . . .... 124
4.16 Comparaison des deux bornes inférieures . . . . . . . . . . . . . . . . . . . .... 125
4.17 Comparaison de la branch and bound avec la programmation dynamique sur la
quatrième série . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .... 126
5.1 Tableau des données . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 128
5.2 Résultats obtenusen utilisant l’algorithme de séparation et d’évaluation . . . . . . 138
5.3 Résultats obtenus en utilisant la programmation linéaire en nombres entiers . . . . 139
5.4 Résultats obtenus en utilisant la programmation dynamique . . . . . . . . . . . . 140
5.5 Résultats des bornes inférieures LB1 et LBLP . . . . . . . . . . . . . . . . . . . . 141

10
Remerciements

Cette thèse a été réalisée à l’Université de Technologie de Troyes au sein de l’équipe Optimisa-
tion des Systèmes Industriels de l’Institut des Sciences et Technologies de l’Information de Troyes.
Je tiens à remercier le Professeur Chengbin CHU, Directeur de cette équipe, de m’avoir accueilli
et de m’avoir encadré durant cette thèse. Ses encouragements et son expérience m’ont permis de
découvrir le monde de recherche.
Je remercie tout particulièrement Monsieur Imed KACEM (Maître de Conférences à l’Uni-
versité de Technologie de Troyes) de m’avoir encadré. Ses conseils, sa disponibilité et sa rigueur
de travail ont été des clés pour réaliser ce travail.
Mes remerciements vont aux membres de jury :
À Monsieur Philippe CHRETIENNE, Professeur à l’Université Pierre et Marie Curie, qui
m’a fait l’honneur d’accepter de présider ce jury de thèse et d’avoir consacré une partie de son
temps pour examiner ce travail.
À Monsieur Mohamed HAOUARI, Professeur à l’Ecole Polytechnique de Tunisie, et Mon-
sieur Michel GOURGAND, Professeur à l’Université Blaise Pascal, d’avoir accepté d’être rap-
porteurs de cette thèse.
À Monsieur Pierre LOPEZ, Chargé de recherche au LAAS de Toulouse, d’avoir accepté d’être
examinateur de cette thèse.
Mes remerciements vont également à tous les membres de l’équipe OSI pour la bonne am-
biance. À mes collègues Adel, Qingning, Rabia, Karim, Lina, Mourad, Caroline. Mes pensées vont
essentiellement à Saïd, Kossi et Djamel.
J’exprime toute ma reconnaissance à tous mes amis Belgacem, Hossem, Neila, Yosra, Sami, Ali,
Racem, Asma, Karim, Chérif, Hédi, Adel, Achraf, Elyess, Amine, Ahmed Essghir, Abdelghani,

11
Yasmine, Dali, Kaïs, Charly, Paula, Bertrant...
Mes derniers remerciements seront à ma famille : mes parents Mohamed et Fatma, mes frères
Sehmeddine, Seifeddine, Seifallah, Mohmed-Essadek, mes soeurs : Sihem, Samira, Semia, Salwa,
Souad, tous mes neveux et nièces, mes oncles M’hamed et Abderrazek et à toutes mes tantes.
Merci à tous, du fond de mon coeur.

12
Introduction

L’ordonnancement occupe une place très importante dans l’organisation des activités d’une
entreprise. En effet, avec la concurrence et la délocalisation qui règnent aujourd’hui dans le monde
économique, les décisions doivent être rapides et sûres pour qu’une entreprise soit compétitive.
L’ordonnancement est une clé déterminante pour maîtriser les coûts de production et pour être
plus réactif.
En outre, les problèmes d’ordonnancement apparaissent dans plusieurs domaines comme l’in-
formatique (tâches : jobs ; ressources : processeurs ou mémoire...), la construction (suivi de projet),
les administrations (emploi du temps, affectation des salariés), l’industrie (problème d’atelier, ges-
tion de la production, problème de placement) [26], [39], [66], [72], [109]. L’intérêt de maîtriser les
aspects de l’ordonnancement est donc double. C’est pourquoi, plusieurs équipes de recherche se
sont penchées sur les problèmes d’ordannancement et sur la conception des méthodes de résolu-
tion pour répondre aux aspects combinatoires de ces problèmes. Toutefois, plusieurs questions et
problèmes restent sans réponse. En effet, le monde industriel devient de plus en plus complexe.
Ses problèmes le deviennent aussi.
Dans cette optique, l’objectif de cette thèse consiste à intégrer quelques spécificités du monde
industriel dans des problèmes d’ordonnancement classiques. De telles spécificités consistent es-
sentiellement dans la prise en compte des temps morts et des indisponibilités des ressources. Ce
choix a été motivé par une réalité industrielle divergente avec le monde académique. Nous al-
lons donc chercher comment adapter certaines méthodes de résolution classiques pour qu’elles
soient efficaces sur des problèmes d’ordonnancement en présence des indisponibilités momenta-
nées des ressources. Ces indisponibilités peuvent avoir deux origines distinctes. D’une part, elles
peuvent être dépendantes de la séquence des tâches à ordonnancer. Ce cas se présente très fré-

13
quemment dans des problèmes d’ordonnancement avec des temps de préparation (setup times
selon le terme anglo-saxon). Dans ce cas, les ressources doivent subir un traitement pour pouvoir
basculer d’un produit à un autre (exemple : nettoyage ou changement des outils dans l’industrie
agro-alimentaire). D’autre part, l’indisponibilité d’une ressource peut être complètement indépen-
dante des tâches à réaliser. C’est souvent le cas d’une maintenance préventive qui rend la ressource
indisponible sur une fenêtre temporelle donnée. Ce type d’indisponibilité est très intéressant car la
maintenaince devient aujourd’hui une partie intégrante de la qualité et tout système doit prévoir
ses opérations de maintenaince. Il est donc primordial d’y penser dès l’étape de l’ordonnancement.
Dans cette optique, ce travail a pour objectif de contribuer à l’étude de problèmes d’ordon-
nancement avec prise en compte de ces deux types d’indisponibilité. Ainsi, ce mémoire s’articule
autour de deux parties. La première partie est consacrée à l’étude de quelques problèmes d’or-
donnancement avec considération des setup times. La deuxième s’intéresse au cas d’indisponibilité
liée à une maintenance préventive.
Le premier problème traité dans la première partie de nos travaux concerne la minimisation
de la somme des retards sur une seule machine avec des temps de préparation dépendants de la
séquence. Une méthode arborescente est proposée. Elle est basée sur une nouvelle borne inférieure
et quelques propriétés de dominance. D’autres propriétés issues de la littérature ont été aussi
intégrées. La comparaison expérimentale de cette méthode avec les résultats de la littérature a été
aussi réalisée et a montré une amélioration significative. Un ensemble d’heuristiques est également
proposé.
Cette étude nous a permis ensuite de considérer deux applications directes. Il s’agit de la mini-
misation de la somme des dates de fin d’une part. D’autre part, nous avons considéré une deuxième
application qui consiste à étudier le problème de minimisation du retard total sur machines pa-
rallèles. Pour tenir compte des spécificités de ces problèmes, nous avons adapté les différentes
propriétés. Nous avons aussi proposé des heuristiques plus spécifiques et plus performantes pour
ces deux problèmes. Les résultats obtenus sont encourageants et prometteurs.
Dans la deuxième partie, le cas d’indisponibilité indépendante a été traité. Deux problèmes ont
été étudiés. D’une part, nous avons considéré le problème de minimisation de la somme pondérée
des dates de fin d’exécution avec une seule indisponibilité. D’autre part, nous avons étudié le

14
critère classique de makespan sous les mêmes hypothèses.
Les méthodes utilisées dans la deuxième partie ont été bien variées. Nous avons conçu et testé
trois approches exactes différentes. D’une part, les problèmes étudiés ont été modélisés grâce à
la programmation linéaires en nombres entiers. Les modèles établis ont été codés et testés avec
un solveur adéquat. D’autre part, plusieurs propriétés mathématiques ont été proposées. De telles
propriétés nous ont permis de construire de méthodes arborescentes très efficaces. Enfin, les pro-
blèmes traités ont été résolus par des algorithmes de programmation dynamique. Ces algorithmes
s’avèrent performants et capables de résoudre des problèmes de taille importante.
Enfin, nous concluons ce mémoire en rappelant les grandes lignes des travaux effectués dans le
cadre de notre étude et en proposant quelques perspectives concernant ce travail de recherche.

15
Chapitre 1

Introduction sur l’ordonnancement

Ce chapitre est une introduction générale aux problèmes d’ordonnancement. Il constitue un


survol rapide de différentes notions nécessaires pour comprendre les problèmes d’ordonnancement.
Ainsi, nous présentons brièvement les définitions de la complexité des algorithmes et des problèmes.
Nous rappelons ensuite les principales méthodes employées pour résoudre de tels problèmes. Enfin,
nous concluons ce chapitre en délimitant le cadre de cette thèse dans ce domaine de recherche.

1.1 Présentation des problèmes d’ordonnancement


1.1.1 Définition

Un problème d’ordonnancement (scheduling en anglais) consiste à affecter un ensemble de


tâches, soumises à certaines contraintes, aux ressources et à décider de leur répartition dans
le temps afin d’optimiser un critère donné ou de trouver un compromis entre plusieurs critères
(voir[10], [53], [109] et [34] ).
Les différentes données d’un problème d’ordonnancement sont les tâches, les ressources, les
contraintes et les critères d’évaluation. Une solution à un problème d’ordonnancement est appelée
un ordonnancement.
Si toutes les informations d’un problème d’ordonnancement (dates de disponibilité des tâches,
durées opératoires des tâches, dates de disponibilité des machines...) sont données a priori, l’ordon-
nancement est dit “statique”. Par contre, lorsque les informations arrivent au fur et à mesure de
16
l’ordonnancement, on parle ici d’un problème d’ordonnancement “dynamique” (ou temps réel).

Les tâches
Une tâche est une entité élémentaire de travail localisée dans le temps par une date de début
t et une date de fin C (completion time). Elle possède une durée opératoire p (processing time).
i i i

Une tâche peut être composée en une ou plusieurs opérations.


Les tâches sont le dénominateur commun des problèmes d’ordonnancement ; leur définition
varie d’un domaine à un autre. Il peut s’agir d’une opération faite par un opérateur et qui demande
une durée précise, comme il peut s’agir d’une pièce à produire sur une machine.
Selon les problèmes, les tâches peuvent être morcelées, c’est-à-dire on peut interrompre l’exécu-
tion d’une tâche à un moment donné puis la reprendre ultérieurement. On parle ici d’un problème
préemptif. Il existe des cas où l’interruption de l’exécution d’une tâche nécessite de recommen-
cer la tâche à nouveau. Il s’agit ici de la préemption répétée (dans les procédés de traitement
thermique). Dans plusieurs configurations, la préemption peut être interdite. Dans ce cas, on ne
peut interrompre l’exécution de la tâche une fois commencée (exemple : procédés de traitement
thermique, industrie chimique...).
Souvent les tâches ont des relations de précédence entre elles. Une tâche i doit être traitée
avant la tâche j (dans ce cas on a : t − t ≥ p ). Dans le cas contraire, on dit que les tâches sont
j i i

indépendantes.

Les ressources
Pour traiter une ou plusieurs tâches, il faut mettre en oeuvre une ou plusieurs ressources qui
peuvent représenter des moyens techniques ou humains. Selon Blazewicz et al., [21] trois types de
ressources sont à distinguer :
◦ Ressource renouvelable. Après avoir été allouée à une ou plusieurs tâches, elle est à
nouveau disponible pour traiter d’autres tâches (les hommes, les machines, les équipements
en général). On distingue par ailleurs les ressources disjonctives (ou non partageables ) qui
ne peuvent exécuter qu’une seule tâche à la fois (machine-outil, robot manipulateur) et les

17
ressources cumulatives qui peuvent être utilisées par plusieurs tâches simultanément mais
en nombre limité (équipe d’ouvriers, poste de travail).
◦ Ressource consommable. La disponibilité s’arrête suite à son utilisation (matières pre-
mières, budget).
◦ Ressource doublement limitée. C’est la combinaison de deux types de ressources citées
précédemment. Par exemple, la pompe à carburant est à la fois une ressource disjonctive (la
pompe) et une ressource consommable (le carburant).

Les contraintes
Les contraintes expriment les limites sur les valeurs et les conditions techniques que peuvent
prendre les variables de décision liées aux tâches et aux ressources qui doivent être respectées
pour l’admissibilité de l’ordonnancement réalisé. Ces contraintes seront détaillées plus loin dans
ce chapitre.

Le(s) critère(s) d’optimisation


Ce sont les objectifs que l’on souhaite optimiser. Généralement, ils sont sous la forme de type
“max” ou de type “somme”. Il peut s’agir d’un seul critère à optimiser (cas monocritère). C’est
le cas le plus répandu dans la littérature. Il peut s’agir aussi de plusieurs critères à la fois (cas
multicritère).
Ces critères peuvent être liés au temps (exemple : le temps total d’exécution, le temps moyen
d’achèvement des tâches, les encours et les retards). Ils peuvent aussi être liés aux ressources
(exemple : le nombre minimal des ressources pour réaliser un ensemble de tâches).

1.1.2 Classification des problèmes d’ordonnancement


Etant donné la diversité des problèmes d’ordonnancement, une classification a été introduite
par Graham et al. [67]. Cette classification permet de distinguer facilement les types des problèmes
d’ordonnancement entre eux. Cette classification a été reprise et révisée par Blazewicz et al. [21].
Elle comporte trois champs d’identification notés α β γ . Le champ α spécifie l’environnement des
| |

18
machines (organisation des ressources). Le champ β désigne les contraintes et les caractéristiques
du système liées à l’exécution des tâches qu’il faut respecter. Enfin, le champ γ désigne les critères
d’évaluation (ou de performance) à optimiser.

Champ α : organisation des ressources


Le champ α consiste en la concaténation en deux sous-champs α1 et α2.
Le sous-champ α1 appartient à l’ensemble {∅, P, Q, R, J, F, O} qui représente le type d’orga-
nistion des machines utilisées :
◦ α1 = ∅ : une seule machine.
◦ α1 = P : machines parallèles identiques. Notons p la durée opératoire de la tâche i sur
ij

la machine M . Les tâches sont à ordonnancer sur des machines disposées en parallèle et à
j

traiter à la même vitesse (p = p ∀j ).


ij i

◦ α1 = Q : machines parallèles uniformes. Les tâches sont à ordonnancer sur des machines
disposées en parallèle et à traiter à des vitesses différentes (p = p /v avec v la vitesse de
ij i j j

la machine M ). j

◦ α1 = R : machines parallèles non liées. Les vitesses d’exécution des tâches dépendent des
machines utilisées ( p = p /v avec v la vitesse de la machine M pour la tâche i).
ij i ij ij j

◦ α1 = J : le problème est du type job-shop. Les tâches sont décomposées en plusieurs opéra-
tions et leur ordre d’exécution est propre à chaque tâche.
◦ α1 = F : le problème est du type flow-shop. L’ordre d’exécution des opérations est le même
pour toutes les tâches. Le flow-shop est un cas particulier du job-shop.
◦ α1 = O : le problème est du type open shop. Dans ce cas, les opérations d’une même tâche
peuvent être exécutées dans un ordre quelconque. Par contre, deux opérations d’une même
tâche ne peuvent pas se chevaucher dans le temps.
Le sous-champ α2 appartient à l’ensemble {∅, m} et désigne le nombre des machines composant
le système :
◦ α2 = ∅ : le nombre des machines est variable.

19
◦ α2 = m : le nombre des machines est fixé à m > 0.
Il arrive que les machines subissent des arrêts volontaires pour une ou plusieurs périodes à
cause d’une maintenance préventive par exemple. A cet effet, la notation α1 α2, h |β |γ concerne
jk

le cas d’une ou de plusieurs périodes d’indisponibilité (j représente la ou les machines concernées


par cette/ces périodes et k représente le nombre des périodes d’indisponibilité).

Champ β : contraintes d’ordonnancement et caractéristiques des tâches


Le champ β ⊆ {β 1, β2, ...} représente les contraintes d’ordonnancement à respecter et les carac-
téristiques du système liées à l’exécution des tâches. Dans ce champ, on peut avoir les informations
suivantes :
◦ pmtn : indique que la préemption des tâches est autorisée. Dans la littérature, une autre
notation est utilisée à savoir : r (resumable) pour l’autorisation de la préemption, nr (non-
resumable) pour l’interdiction de la préemption et sr (semi-resumable), si la préemption
est autorisée mais la tâche interrompue reprendra son exécution partiellement (par exemple
dans la construction métallique, si le chauffage d’une pièce métallique est interrompu pen-
dant un certain temps, la reprise d’échauffement ne sera pas au même point d’arrêt ; il faudra
ramener la pièce à la même température lors d’interruption puis continuer le reste). Cette
notation est généralement associée à la contrainte d’indisponibilité de la machine [100].
◦ split : les tâches peuvent être décomposées en morceaux qui peuvent être exécutés en même
temps.
◦ res : désigne qu’une oprération necessite une ou plusieurs ressources supplémentaires (outils,
opérateurs, ressources de transport, ...).
◦ prec : contraintes de précédence générales entre les tâches.
◦ tree : contraintes de précédence sous forme d’arbres.
◦ chain : contraintes de précédence sous forme de chaînes.
◦ r : date de disponibilité (ou date de début au plus tôt, ou date d’arrivée) de la tâche i pour
i

être opérationelle dans le système.


◦ p = p : les temps de traitement des tâches sont identiques et égaux à p.
i

20
◦ p ≤ p ≤ p : les temps de traitement des tâches sont compris entre p et p.
◦ d : date d’échéance de la tâche i qu’il faut impérativement respecter.
i

◦ S : temps de changement d’outil (setup time) constant. Il est parfois nécessaire de considérer
un temps entre le traitement de deux tâches pour effectuer des réglages sur la machine ou
pour faire le montage et/ou le démontage d’un opérateur.
◦ S : temps de changement d’outil (setup time) qui varie en fonction de la tâche i.
i

◦ S : temps de changement d’outil (setup time) entre deux tâches successives i et j . Ce


i, j

temps dépend de la séquence.


◦ R : temps de démontage indépendant de la séquence.
si

◦ R : temps de démontage dépendant de la séquence.


sd

◦ b +1 : quantité de stockage limitée entre j et j + 1.


i, i

◦ nwt (no − wait) : les tâches doivent être opérées sur la machine sans aucune attente. On
trouve cette contrainte dans les industries de fonderie où on ne peut faire attendre un metal
en fusion.

Champ γ
Dans ce paragraphe, nous allons présenter les différents critères les plus traités dans la littéra-
ture. Pour cela, nous allons illustrer ces critères sur le problème d’ordonnancement de N tâches
sur une machine.
Soit C la date de fin d’exécution (completion time) de la tâche i, i = 1, ..., N .
i

◦ γ = Cmax = max1≤ ≤N Ci : on l’appelle souvent le makespan. C’est la plus grande date de


i

fin d’exécution.
◦ γ = Dtmax = max1≤ ≤N (Ci + qi) : C’est la plus grande date de livraison. qi est appelé durée
i

de latence qui est le temps nécessaire entre la fin d’exécution de la tâche i sur la machine et
la date de la livraison effective au client.
◦ γ = N Fi : c’est la somme des durées de séjour des tâches dans le système, avec Fi = Ci − ri
i=1
et r la date de disponibilité de la tâche i.
i

21
◦ γ = N1 Ni=1 Fi : temps moyen de séjour.
◦ γ= N i=1 wi Fi : la somme pondérée de temps de séjour, avec wi le poids assossié à la tâche
i.
◦ γ = Ni=1 Ti c’est le retard total (total tardiness) ou la somme des retards des tâches, avec
:

T = max {C − d , 0} et d la date d’échéance souhaitée (date de livraison ou due date).


i i i i

◦ γ = Ni=1 w T : somme pondérée des retards des tâches.


i i

◦ γ= N i=1 Ei : somme des avances (earliness) avec Ei = max {d − C , 0}.


i i

◦ γ = Lmax = maxi≤N (Ci − di ) : décalage temporel maximal (lateness). C’est la mesure de la


plus grande violation des dates d’échéances souhaitées.
1 si C >d
◦ γ= N i=1 Ui , Ui = {0 sinon : le nombre des tâches en retard.
i i

1.2 Complexité des problèmes d’ordonnancement


Dans cette partie, on s’intéresse aux notions de complexité d’algorithme. Elle couvre deux
champs : la complexité des algorithmes et la complexité des problèmes.

1.2.1 Complexité des algorithmes


C’est un indicateur de performance permettant de comparer les algorithmes. Par exemple,
pour comparer deux algorithmes conçus pour un même problème, on peut mesurer leurs perfor-
mances indépendantes de l’ordinateur et du langage utilisés. Cela peut se faire en dénombrant
les opérations élémentaires (affectation, comparaison, opérations arithmétiques, évaluation d’une
expression ...) effectuées par l’algorithme. C’est la complexité de l’algorithme.
La complexité d’un algorithme peut être notée ( ( )) avec ( ) une combinaison de poly-
O f n f n

nômes, logarithmes ou exponentielles et le nombre des entrées d’une instance de problème. Elle
n

signifie que le nombre des opérations élémentaires est majoré par ( ) lorsque tend vers l’infini
cf n n

( est une constante).


c

On considère le comportement de la complexité à l’infini car l’explosion des temps de réponse


d’un algorithme est généralement constatée lorsque la taille des données est grande. L’ordre crois-
sant de quelques grandeurs classiques de complexité est le suivant :
22
O (1) , O (log (n)) , O (nx ) , c n
O (n) , O (n. log (n)) , O (n ) , O (c ) , O (n!)

avec 0 < x < 1 < c

◦ O (1) : constante,
◦ O (log (n)) : logarithmique,
◦ O (n) : linéaire,
◦ O (n. log (n)) : combinaison linéaire et logarithmique,
◦ O (n ) :
2 quadratique,
◦ O (n ) :
3
cubique,
◦ O (2 ) :
n
exponentielle.
On peut distinguer quelques grandes classes de complexité :
◦ Les algorithmes sub-linéaires : ce sont des algorithmes très rapides. Leur complexité est en
général en . C’est le cas de la recherche d’un élément dans un ensemble ordonné
O (Log(n))

fini de cardinal . n

◦ Les algorithmes linéaires en complexité O (n) (l’évaluation de la valeur d’une expression


composée de symboles) ou en
n O (n.Log(n)) (pour certains algorithmes de tri).

◦ Les algorithmes en complexité polynomiale nk si 2 ≤ k ≤ 3, les algorithmes sont
O :

considérés plus lents (c’est le cas de la multiplication des matrices et du parcours dans les
graphes). Pour k > 3, les algorithmes sont considérés comme lents.
Plus loin, les algorithmes exponentiels sont considérés comme très lents, la complexité est
supérieure à tout polynôme en n.

1.2.2 Complexité des problèmes


Dans la littérature, il existe des problèmes faciles et d’autres difficiles à résoudre. Dans certains
cas, on peut résoudre des problèmes avec des algorithmes polynomiaux alors que d’autres n’en ont
pas encore. Une question qui se pose, est-ce qu’il y aura un jour des algorithmes polynomiaux qui
puissent résoudre les problèmes difficiles ?

23
La théorie de la complexité se base sur les problèmes de décision (ou de reconnaissance) pour
comparer et évaluer les complexités des problèmes. Les solutions de tels problèmes sont des ré-
ponses par “oui” ou par “non”. A titre d’exemple, on peut associer un problème de décision au
problème très connu de voyageur de commerce (PVC). Ce problème peut être simplement formulé
dans la question suivante : existe-t-il un chemin de longueur inférieure à 25 Km ?
La plupart des problèmes que nous étudions peuvent être formulés comme des problèmes
de décision ou des problèmes d’optimisation. La théorie de complexité a révélé une équivalence
intéressante entre les deux types des problèmes [26].

Classe NP (Non déterministic Polynomial time)


Un problème de décision appartient à la classe NP , si pour toute instance de ce problème on
peut vérifier en un temps polynomial que la réponse est oui pour cette instance. On distingue deux
grandes sous classes dans la classe NP : les problèmes faciles à résoudre qui sont les problèmes
polynomiaux (représentés par la classe P : Polynomial-time) et les problèmes difficiles à résoudre
(classés dans la classe NP − Complet : NPC).

Classe P (Polynomial-time)
Un problème de décision appartient à la classe P , s’il existe un algorithme A et un nombre k
tels que pour toute instance I du problème, l’algorithme donne une solution en temps polynomial
O nk où n est le nombre des données d’entrée qui représente I .

Classe NP-Complet (NPC)


Un problème appartient à la classe NP − Complet, s’il n’existe pas d’algorithme polynomial
connu pour résoudre ce problème d’une manière optimale.
Pour montrer qu’un problème P1 est NP − Complet, il faut d’abord qu’il appartienne à la
classe NP . Ensuite, il faut trouver un autre problème P2 connu d’être NP − Complet et qui se
réduit polynomialement à P1 (cette réduction est notée P2 ∝ P1).
La technique de réduction polynomiale (ou transformation polynomiale) [105] peut être décrite
comme suit :

24
Un problème de décision Π1 est réductible au problème Π2 (noté Π2 ∝ Π1) s’il existe une
fonction polynomiale f qui transforme toute instance I1 de Π1 en une instance f (I1) = I2 de
Π2 de telle sorte que la réponse au problème Π1 pour l’instance I1 est “oui” si et seulement si la
réponse au problème Π2 pour l’instance I2 est “oui”.
Si un jour on trouve un algorithme qui peut résoudre un problème NPC en un temps polyno-
mial (P = NP ), on sera donc capable de résoudre tous les problèmes de NPC avec des algorithmes
polynomiaux.

Classe NP-Difficile (NPD)


On utilise souvent dans la littérature le terme NP − Difficile. Ce terme peut définir les
problèmes pour lesquels il n’existe pas d’algorithme de résolution en un temps polynomial en
fonction de la taille des données.
Suivant leurs difficultés, on distingue des sous catégories des problèmes NPD. D’une part, les
problèmes NP − Difficiles au sens ordinaire (ou tout simplement NP − Difficiles). Dans ce
cas, on peut résoudre le problème en un temps polynomial avec un décodage unaire des données
alors que ce n’est pas le cas pour le décodage binaire. Ce type de problème est appelé aussi
Pseudo − Polynomial. D’autre part, lorsqu’il n’existe aucun algorithme de résolution en temps
polynomial pour n’importe quel codage, il s’agit ici des problèmes NP − Difficiles au sens fort.

1.3 Méthodes de résolution

Pour un problème d’ordonnancement de n tâches sur une machine, on peut utiliser une méthode
simple qui consiste à énumérer toutes les solutions possibles et retenir, par la suite, la meilleure.
Cette démarche est, certes, très simple et faisable pour une petite taille de problème. En revanche,
le temps de réponse pour obtenir la solution augmente considérablement avec la taille du problème.
En effet, il nous faudra n solutions possibles pour une taille de tâches. On suppose qu’un
! n

ordinateur peut évaluer une solution en − 9 secondes. Pour une taille de tâches, il y aura
10 10

3628800 solutions possibles. Le problème sera donc résolu dans 0, 036 secondes. En revanche,

25
pour une taille double , on aura
(n = 20)
18 solutions possibles et la résolution complète du
2, 4.10

problème nécessite environ ans!


77

La limite des méthodes exhaustives a donc poussé les chercheurs à chercher d’autres approches
alternatives. Ces méthodes sont réparties en deux classes : les méthodes exactes et les méthodes
approchées.

1.3.1 M éthodes exactes


Les méthodes exactes garantissent des solutions optimales pour n’importe quelle instance nu-
mérique mais ne garantissent pas d’y arriver en temps polynomial. Parmi ces méthodes on trouve :
◦ la procédure par séparation et d’évaluation (branch and bound en anglais),
◦ la programmation linéaire en nombres entiers,
◦ la programmation dynamique.

Méthode de séparation et d’évaluation (branch and bound)

La méthode de séparation et d’évaluation (branch and bound ou PSE) est une procédure
d’exploration par énumération arborescente implicite. Elle consiste à construire une arborescence
et à éviter les branches inutiles, d’où le nom synonyme de méthode d’énumération implicite. Les
travaux qui utilisent cette méthode sont très nombreux dans la littérature (Little et al [108] et
Miller et Pekny [112]).
Dans cette méthode, la recherche se fait sur un arbre constitué des sommets. Chaque sommet
représente une solution partielle (ou un sous ensemble de solutions) sous forme d’un noeud i qui
contient les informations sur la solution partielle ou le sous ensemble avec la borne inférieure (pour
le cas de minimisation) notée B ; cette borne est calculée lors de la création du noeud (lower bound
i

en anglais).
La démarche suivie dans une PSE est basée sur trois composantes (voir figure 1-1) :
◦ la séparation (branchement),
◦ fonction d’évaluation,
◦ la stratégie d’exploration.
26
La séparation A partir d’un noeud appelé noeud père, on procède à la création d’un certain
nombre de noeuds fils.

L’évaluation Pour chaque noeud sélectionné, on décide soit de faire la séparation et continuer
la recherche de la solution optimale ou de s’arrêter à cette branche et voir un autre noeud. Cette
décision est faite à l’aide de la borne inférieure de la solution partielle ou à l’aide d’une propriété
de dominance.
◦ La borne inférieure. C’est une valeur obtenue par une relaxation de certaines contraintes
considérées au départ pour le problème et qui permet de donner des informations sur la
performance du noeud évalué au meilleur des cas.
◦ Propriété de dominance. Elle permet de déterminer les branches qui sont susceptibles
d’aboutir à une solution optimale. Ceci se fait par la comparaison des caractéristiques ma-
thématiques de deux séquences partielles. Par conséquent, on sait quelle séquence domine
d’autres.

La stratégie d’exploration Après la séparation d’un noeud, on doit choisir le prochain noeud
à séparer. Ceci, se fait par l’application d’une politique d’exploration telle que l’exploration en
profondeur d’abord (Depth first), l’exploration en largeur d’abord (Breadth exploration) ou de
choisir le noeud qui possède la borne inférieure la plus petite (Meilleur d’abord ou Best first).

L’algorithme de PSE A chaque étape de l’algorithme, on dispose des éléments suivants :


◦ Une liste de solutions partielles actives.
◦ Une borne supérieure BS (upper bound en anglais) : la meilleure solution obtenue. La valeur
initiale de la borne supérieure est calculée à partir d’une heuristique qui donne une solution
admissible. La borne supérieure est susceptible d’être changée au cours de la PSE .
La démarche de la procédure par séparation et évaluation est illustrée dans la figure 1-1.

27
Niveau 0 :
S

Bi(S )<BS
1
Bi(S )<BS
2

Niveau 1 : S1 S2 S3 ... Sn

Bi(S )>BS dominée par S


fin de
3

fin de
2
la recherche
la recherche

Niveau 2 : S1, 1 S1, 2


... S1, n-1

Bi(S )=BS
fin de
1, n-1

la recherche

Niveau k : S1, 1,…,1

S1, 1, …, 1, 1 S1, 1, …, 1, 2 ... S1, 1, …, 1, n-k

F . 1-1: Schéma de la procédure de séparation et d’évaluation

Programmation linéaire
La programmation linéaire est une méthode générique se basant sur la modélisation mathéma-
tique. Avec cette méthode, on peut associer à un problème d’optimisation un modèle mathématique
dans lequel le critère et les contraintes sont fonctions linéaires des variables. Un modèle linéaire
peut s’exprimer sous la forme compacte suivante :

max =1 c x
n
i i i : fonction objectif

  =1 a x ≤ b i = 1, . . . ,m : les contraintes du problème


 n
j ij j i


 x sont des réels
j

ou encore la forme développée suivante :


max c1x1 + . .. + cnxn

28


 a11x.1 + . .. + a.1 x ≤

 n n b1

.. + + .. ≤ ...


...


 m1 1 + + mn m ≤
a x ... a x b m
La résolution des problèmes linéaires à variables réelles peut être effectuée par la méthode de
Simplexe, les méthodes des points intérieurs, ou la méthode graphique dans certains cas parti-
culiers. Plusieurs logiciels commerciaux offrent aujourd’hui cette possibilité (exemple : LINDO,
LINGO, GAMS ou CPLEX).

Programmation linéaire en nombres entiers mixtes


Souvent dans les problèmes d’ordonnancement, on manipule des variables qui sont indivisibles
(variables entières) (des pièces mécaniques, des bouteilles, des objets...). La programmation linéaire
à variables réelles ne correspond plus à de telles situations. Dans ce cas, il faut faire appel à la
programmation linéaire en nombres entiers ou mixtes. A cause de la non continuité des variables,
il est plus difficile de résoudre un problème linéaire en nombres entiers qu’un problème à variables
réelles. Souvent on relaxe les contraintes d’integrité pour avoir des bornes inférieures (pour le cas
de minimisation) que nous pouvons intégrer dans les méthodes arborescentes.
Nous allons illustrer cette méthode par un exemple du problème de sac à dos (Knapsack
Problem en anglais). Ce problème se formule comme suit :
Un voyageur veut charger son sac à dos de capacité maximale V (volume ou poids...) avant de
partir. Il dispose de n objets numérotés de 1 à n. On considère que chaque objet est en un seul
exemplaire. Il s’agit ici d’un problème de sac à dos binaire. Chaque objet i a un volume v et une
i

utilité c . Le voyageur cherche à déterminer les objets à prendre en maximisant l’utilité totale sans
i

dépasser la capacité maximale du sac à dos. Dans ce problème, on considère que les objets sont
indivisibles.
Nous allons modéliser le problème en introduisant n variables de décision x1 2 .A
, x , . . . , xn

l’étape on décide de prendre l’objet ( = 1) ou non ( = 0). L’utilité de l’étape correspond


k k, xk xk k

à l’utilité de l’objet s’il est sélectionné ( ). Donc le problème peut être modélisé sous la forme
k ck .xk

mathématique suivante :
max =1n
i
ci xi

29
 

 =1 ≤ n
i
vi xi V


 ∈ {0 1} ∀
xi , i = 1, ..., n

Programmation dynamique
La programmation dynamique a été introduite par Bellman ([17] et [18]). Elle est destinée à
certains problèmes d’optimisation qui peuvent être décomposés en étapes si les critères présentent
certaines propriétés particulières (par exemple une forme additive). L’idée générale est de décom-
poser le problème en étapes. Chaque étape correspond à un sous problème d’ordre inférieur à
n n

( −1 −2
n ,n 1) que l’on résout optimalement en tenant compte des informations de l’étape
,...,

précédente. Le critère sera formulé par une relation de récurrence.


Reprenons l’exemple du problème de sac à dos. Il peut être décrit par le modèle suivant :
 max =1
n
ci xi

  =1 ≤

i
n
i vi xi V


 ∈ {0 1} ∀
xi , i = 1, ..., n
Soit σ (k) la valeur de la solution optimale correspondant à un sac à dos de capacité k (0 ≤
k ≤ V ) et un ensemble d’objets {1, 2, ..., i} (i ≤ n). On peut écrire l’équation de récurrence comme
suit :

σ (k, i) = max {ci + σ (k − vi , i − 1) , σ (k, i − 1)} (1.1)


en tenant compte des conditions initiales suivantes :

σ (k, i) = 0 si k < min


i
{vi}

Le problème se ramène donc à trouver σ∗ = maxk≤V σ (k, n). Ce calcul nécessite donc un
algorithme de complexité ( ). O n.V

1.3.2 Méthodes approchées

Comme nous avons déjà vu dans un paragraphe précédent, les problèmes − de NP Dif f iciles

grande taille demandent un temps considérable pour trouver une solution optimale. Le méthodes

30
approchées permettent de fournir de bonnes solutions dans un temps raisonnable et représentent
une bonne alternative aux méthodes exactes.

Méthodes heuristiques par construction


Ce sont des méthodes itératives destinées à compléter une solution partielle. La plupart de ces
méthodes sont des algorithmes gloutons (greedy methods). Le choix d’ordre des tâches obtenu par
ces méthodes est définitif. Nous présentons les deux méthodes les plus utilisées :
◦ Les algorithmes de liste. Le principe de ces algorithmes est d’ordonner la liste des tâches
en respectant une stratégie de décision telle que SPT (Shortest Processing Time), EDD (Ear-
liest Due Date), FIFO (First In First Out). Malgré leur simplicité apparente, ces algorithmes
donnent souvent de bonnes solutions.
◦ Méthodes de construction progressives. Le principe de ces méthodes est le suivant. A
chaque itération, nous disposons d’une séquence partielle de tâches et on décide de choisir
une tâche parmi celles qui ne sont pas encore ordonnancées selon une règle de priorité. On
ajoute ensuite cette tâche à la séquence partielle et on met à jour l’ensemble des tâches non
ordonnancées. Le processus est répété tant qu’il existe des tâches non ordonnancées.

Méthodes par décomposition


Elles consistent à décomposer le problème en plusieurs sous problèmes. Parmi ces méthodes,
on distingue : la décomposition hiérarchique, temporelle et spatiale.
◦ La décomposition hiérarchique [52]. Elle consiste à décomposer le problème en plusieurs
niveaux. Les décisions prises à un niveau supérieur deviennent des contraintes pour les
niveaux inférieurs.
◦ La décomposition temporelle [119]. Elle est utilisée souvent pour les problèmes d’or-
donnancement dynamique (ou en temps réel) puisqu’on ne connait pas les dates d’arrivée
des tâches à l’avance. On procède comme suit. On ordonnance les sous ensembles des tâches
disponibles avant la date T1. Les tâches qui se terminent avant cette date T1, sont retenues
dans la séquence partielle. On groupe les tâches restantes avec les tâches qui deviennent

31
disponibles entre la date T1 et la date T2. Et on procède de la même manière jusqu’à ce que
toutes les tâches soient ordonnancées.
◦ La décomposition spatiale [35]. Elle consiste à décomposer l’atelier en plusieurs sous
ateliers en essayant de réduire au maximum les déplacements entre ces sous ateliers et puis
procéder à l’ordonnancement des tâches dans chacun de ces ateliers et à coordonner ces
derniers.

Méthodes heuristiques amélioratrices


Elles ne sont pas des méthodes spécifiques pour construire un ordonnancement. Comme le
nom l’indique, ce type d’approches permet d’améliorer des séquences résultantes des méthodes
heuristiques par décomposition ou par construction.
Ces méthodes sont basées sur la notion de voisinage ; c’est-à-dire, elles consistent à transformer
une séquence en une séquence voisine en permutant, par exemple, deux tâches. On distingue
plusieures méthodes telles que :
◦ Les méthodes de recherche locale (local search). Les méthodes de recherche locale se
basent sur la notion du voisinage. Le principe est le suivant. A partir d’une solution initiale
x0 , considérée comme un point de départ, on applique à cette solution des transformations
successives tant qu’un critère d’arrêt n’est pas vérifié. L’avantage de ces méthodes consiste
en une mise en oeuvre assez simple. En revanche, l’inconvénient est qu’elles ne sont pas
adaptées à des fonctions objectifs multimodales (avec plusieurs creux et pics). En effet, la
recherche s’arrête dès qu’un optimum local est obtenu. C’est le cas de la méthode de la
descente.
◦ Méthode de la descente (ou Algorithme du Grimpeur “Hill Climbing”). Le prin-
cipe de cette méthode est simple. Elle consiste à choisir à partir de la solution courante x, le
voisinage qui donne la meilleure solution x parmi les solutions au voisinage noté V (x) (voir
la figure 1-2). L’algorithme correspondant à cette méthode est donné dans la figure 1-3.

◦ La méthode tabou (tabou search). Cette méthode a été introduite par Glover [63].
Son principe repose sur l’interdiction de reprendre des solutions récemment visitées. Cela

32
F . 1-2: Méthode de descente

Début
Initialisation : générer une solution initiale x
Mini = f (x)
Répéter tant que le critère n’est pas vérifié
Trouver une solution x V (x)
∈ telle que f (x ) =xmin
∈V x
( )
f (x)
Si f (x ) ≤ f (x) Alors x = x
fin
F . 1-3: Algorithme de la méthode de la descente

se fait en construisant une liste notée LT (Liste Tabou) de taille L qui représente les der-
nières solutions rencontrées. Cette méthode permet l’exploration des solutions non visitées et
d’éviter les cycles, c’est à dire la répétition infinie d’une séquence de mouvements. Plusieurs
contributions ont été apportées à cette méthode, notamment par Widmer [161] pour l’op-
timisation des ateliers flexibles. L’algorithme correspondant à cette méthode est représenté
dans la figure 1-4.

◦ Le recuit simulé (simulated annealing). Cette méthode à été développée par Kirk-
patrick et al. [88]. Elle s’inspire du domaine de la thermodynamique et est basée sur un
algorithme de simulation des recuits des métaux. Cette méthode a presque le même principe
de voisinage que la recherche locale. La seule différence est que ce voisinage est sélectionné
avec une certaine probabilité. Il se trouve que la solution sélectionnée soit moins bonne que

33
Début
1. Initialisation : générer une solution initiale x
M ini = f (x)
LT = φ
2. Trouver une solution x V (x) et x / LT telle que f (x ) =x∈V min
∈ ∈
( ) ∈ x ,x / LT
f (x)
Si f (x ) f (x) Alors x = x mise à jour de LT

3. Aller à l’étape 2 si la condition d’arrêt n’est pas vérifiée


fin
F . 1-4: Algorithme de la recherche tabou

d’autres et ceci permet d’échapper à un optimum local. On pourra donc espérer une amélio-
ration ultérieure. Cette méthode a été utilisée par plusieurs chercheurs dans de différentes
applications pour l’optimisation des systèmes de production ([116] et [75]). Cette méthode
est présentée sous forme d’algorithme dans la figure 1-5.

Début
Générer une solution initiale S(0)
Mini = S (0)
Répéter
Choisir au voisinage

S ∈V S (i) (0)

Calculer ∆f = f S − ( (i) ) f M ini

Si ∆ ≤ 0 Alors
f = M ini // (même que pour l’algorithme de descente)
S(i)

Sinon générer aléatoirement une probabilité suivant la distribution uniforme [0 1]


P ,

Si P < e
−∆f /T ) Alors
(
= (i) // (Solution moins bonne)
M ini S

Sinon (i) est rejetée


S

T = ( ) // (avec ( ) , par exemple ( ) = 0 9995 T )


g T g T < T g T , ·

Jusqu’à ce que T soit proche de 0


fin
F . 1-5: Algorithme du recuit simulé

◦ Les algorithmes génétiques (genetic algorithms). Ces algorithmes ont été introduits
par John Holland [76] de l’Université du Michigan en 1975, puis développés par d’autres cher-
cheurs tels que Goldberg [64], Davis [40]. C’est l’adaptation des propriétés des phénomènes
de l’évolution naturelle et de la reproduction des êtres vivants aux problèmes combinatoires
complexes. Leur principe est donc une transposition artificielle des concepts de la génétique
34
et des lois de survie énoncés par Charles Darwin. Dans ces méthodes, on part généralement
d’une population initiale de taille n qui représente un ensemble de solutions qui sont ob-
tenues aléatoirement ou par des méthodes heuristiques. Chaque solution est codée par des
chaînes des symboles. Les solutions sont aussi appelées individus ou chromosomes. Une
solution représente donc une séquence finie de gènes pouvant prendre des valeurs significa-
tives. Chaque chromosome est caractérisé par une fitness (une sorte de mesure d’adaptation
au milieu ou la valeur du critère pour cette solution). L’idée de base d’un algorithme géné-
tique consiste à tirer au sort deux parents selon une loi de distribution favorisant les individus
les plus adaptés (sélection). On applique un opérateur de croisement (crossover) sur les
deux chromosomes parents pour générer deux enfants. Les opérations de croisement sont
faites suivant des méthodes appelées opérateurs qui dépendent du problème étudié. Citons
à titre d’exemple les opérateurs suivants :
Opérateur de croisement LOX (Linear Order Crossover [55]).
Opérateur de croisement OX (Order Crossover [118]).
Opérateur de croisement X1.
Les individus peuvent également subir une transformation individuelle appelée opérateur
de mutation. La mutation est effectuée selon une probabilité. On choisit aléatoirement un
individu et on effectue un changement au niveau de ses gènes (exemple : permutation de deux
gènes (tâches) ou déplacement). Le chromosome résultant remplacera un autre chromosome
dans la population (insertion). En revanche, on garde toujours le meilleur chromosome
dans la population. Les enfants servent à reconstruire la génération suivante ou remplacent
directement des individus de la population. Le processus est répété jusqu’à vérifier un critère
d’arrêt (souvent un nombre maximal d’itérations ou un temps maximal). Cette méthode a été
utilisée dans plusieurs références bibliographiques pour plusieurs applications industrielles
([160], [23], [155], [19], [69], [87], [58], [79], [59]).

35
1.4 Présentation du contexte abordé

Le survol bibliographique que nous venons de présenter montre une littérature abondante dans
le domaine d’ordonnancement. Plusieurs approches existent et permettent une résolution efficace
pour plusieurs types de problèmes. L’objectif de ce travail est de contribuer dans ce domaine
en tenant compte de certaines contraintes de plus en plus fréquentes dans le domaine industriel.
Il s’agit de l’indisponibilité de ressources qui peuvent subir des opérations de maintenance ou
de préparation. Dans cette optique, notre problématique consiste à intégrer ces spécificités dans
des problèmes d’ordonnancement classiques. En effet, les temps morts et les indisponibilités des
ressources sont une réalité dans le domaine de la production. Le choix d’une telle problématique a
été motivé par un besoin industriel réel. Nous allons nous baser sur les résultats de la littérature
pour adapter les méthodes de résolution classiques pour qu’elles soient efficaces sur des problèmes
d’ordonnancement en présence des indisponibilités diverses des ressources.
Les indisponibilités peuvent avoir de diverses origines. Principalement, nous allons nous inté-
resser à deux types d’indisponibilité :
◦ Type dépendant. Pour ce type, elles peuvent directement dépendre des tâches à effectuer.
C’est le cas, par exemple, dans les problèmes d’ordonnancement avec des temps de prépa-
ration (setup times). Pour ce type de problèmes, les ressources doivent subir un traitement
pour pouvoir changer de tâche ou pour passer d’une tâche à une autre.
◦ Type indépendant. L’indisponibilité peut être totalement indépendante des tâches à effec-
tuer. C’est souvent le cas d’une maintenance préventive qui rend la ressource indisponible sur
une fenêtre temporelle donnée. Ce type d’indisponibilité est très fréquent car la maintenaince
devient aujourd’hui une opération nécessaire tôt ou tard pour assurer le bon fonctionnement
d’un système. On doit donc prévoir des opérations de maintenaince qui, en conséquence,
conduisent à des indisponibilités forcées. Il est sans doute nécessaire de prendre ces éléments
en considération dans la phase d’ordonnancement.
Les problèmes qui sont traités dans ce mémoire sont des problèmes classiques mais intègrent
la notion de l’indisponibilité de ressources dans les deux versions indépendante et dépendante.
Quelques types de critères seront essentiellement considérés. Il s’agit de la somme des retards, la

36
somme des dates de fin (pondérées et non pondérées) et le makespan. Les formulations exactes
des problèmes seront présentées au fur et à mesure. Les approches développées dans ces travaux
sont du type exact. L’avantage de telles approches par rapport aux métaheuristiques réside dans
leur fondement basé sur des principes scientifiques. Il est toujours plus convaincant de se baser
sur ces principes pour assurer l’efficacité d’une méthode de résolution. C’est pourquoi, nous avons
opté pour ce choix.

1.5 Conclusion
Les recherches en ordonnancement paraissent de plus en plus nombreuses et efficaces. Plusieurs
approches et méthodes ont été développées au cours des dernières décennies pour pallier aux
différents problèmes. Toutefois, plusieurs spécificités supplémentaires apparaissent dans le domaine
industriel et nous incitent à étudier leur impact sur les méthodes déjà élaborées. En particulier,
les indisponibilités des ressources sont de plus en plus fréquentes. Dans la suite de ce mémoire,
nous présentons à travers quelques exemples comment ces spécificités peuvent être intégrées.

37
Chapitre 2

Ordonnancement avec prise en compte


des temps de préparation : étude de
1|Si,j | Ti

Dans ce chapitre, nous présentons un cas d’indisponibilité dépendante. Il s’agit d’un problème
à une machine unique avec des temps de préparation de la ressource. Ces temps de préparation
dépendent de la séquence choisie. L’objectif est de minimiser la somme des retards. Pour résoudre
ce problème, nous proposons d’utiliser deux bornes inférieures et quelques propriétés de dominance.
Plusieurs heuristiques sont également présentées. Nous discutons enfin les résultats de différentes
simulations réalisées pour évaluer l’approche.1

2.1 Introduction

La plupart des travaux de la littérature dédiés aux problèmes d’ordonnancement supposent


que les machines sont toujours disponibles. Cependant, les ressources sont souvent arrêtées pour
effectuer les opérations de préparation. C’est le cas dans plusieurs domaines industriels. Ces pré-
parations peuvent être de différentes natures selon le processus utilisé. On peut citer par exemple
1
Ce chapitre a fait l’objet des publications [147], [144] et [145].

38
le changement d’outil et de production (montage et démontage), les réglages, les nettoyages, les
inspections, etc... Ci-dessous quelques domaines industriels concernés.
◦ Industrie chimique. En raison de différentes propriétés des produits chimiques qui sont
fabriqués, des résidus doivent être enlevés de la machine (réacteur, récipient, etc...) et des
filtres doivent être nettoyés ou même changés lors d’un changement de production [141]. Ces
changements sont souvent coûteux à cause de leurs durées, parfois, importantes.
◦ Industrie de teinture de tissus ou d’autres produits. Le changement de couleur prend
plus du temps lorsqu’on passe d’une couleur foncée à une couleur claire. Par exemple, avec
un ordre de production en utilisant un spectre de peintures colorées allant du blanc au noir,
le temps est plus court que celui d’un ordre allant du noir au blanc.
◦ Industrie d’injection de matière plastique. Le changement de production est traduit
souvent par le changement des moules.
Ces opérations de préparation exigent une immobilisation de la machine et nécessitent des
heures, et parfois des jours, pour être effectuées. Elles peuvent avoir des répercutions non né-
gligeables sur la productivité, surtout si leurs fréquences ou leurs durées sont importantes. Elles
peuvent engendrer des pénalités à payer dues aux retards ou induire des frais supplémentaires de
sous-traitance.
Malgré le progrès technologique et l’apparition de nouveaux concepts permettant de dimi-
nuer les durées de préparation (comme la technique SMED2 ), celles-ci restent dans plusieurs cas
industriels très significatives. Cependant, elles étaient souvent négligées dans les études en ordon-
nancement ou considérées comme incluses dans les durées opératoires [7]. Il est donc nécessaire
de revoir certaines approches pour qu’elles soient adaptées au contexte industriel. Van Goubergen
[157] catégorise les différentes raisons pour considérer des petites durées de changement d’outil en
trois principaux groupes :
2
Selon la norme AFNOR NF X50-310, le SMED est une méthode d’organisation qui cherche à réduire de façon
systématique le temps de changement de série de fabrication (Single Minute Exchange of Die). Cette technique a
été développée par l’ingénieur japonais Shigeo Shingo [142] pour réduire les temps de changement d’outil. Cette
méthode fournit des approches simples pour améliorer les temps de changement d’outil existants et pour obtenir
facilement des réductions jusqu’au 90% surtout avec des investissements modérés. Plusieurs publications et études
des cas sont disponibles dans la littérature pour minimiser les temps de changement d’outil dans des situations
différentes ([142], [140], [151], [73], [62] et [65]).

39
◦ La flexibilité. Avec la croissance de la variété des produits pour les consommateurs et
la décroissance de la quantité de chaque référence, les entreprises doivent être capables de
réagir au plus vite en imposant de petits temps de préparation.
◦ Effet sur le goulot d’étranglement. Pour les machines du type goulot d’étranglement,
chaque minute perdue compte. En conséquence, les temps de préparation doivent être mini-
misés pour maximiser la capacité de disponibilité pour mieux produire.
◦ Minimisation des coûts. Les coûts directs de la production sont liés à la performance de
la machine. Le calcul d’efficacité totale des équipements peut facilement montrer l’impact
des temps de préparation sur la performance de la machine.

2.2 Survol bibliographique

Dans cette section, nous présentons un état de l’art sur les problèmes d’ordonnancement avec
prise en compte des temps de préparation. On distingue principalement deux types de temps
de préparation : les temps de préparation dépendants de la séquence des tâches et les temps de
préparation indépendants de la séquence des tâches.
◦ les temps de préparation dépendants de la séquence. Dans ce cas, les temps de pré-
paration dépendent de la séquence des tâches ordonnancées. Dans une séquence, si une tâche
i précède directement une autre tâche j , alors un temps de préparation S est nécessaire
i,j

entre l’exécution de deux tâches. L’ensemble de ces temps {S } constitue une matrice de
i,j

temps. Cette matrice peut être symétrique (S = S ) ou asymétrique (S = S ).


i,j j,i i,j j,i

◦ les temps de préparation indépendants de la séquence. Ce sont des temps indépen-


dants de la succession des tâches dans la séquence. En général, ils sont des temps de montage
ou de démontage :
les temps de montage. Avant qu’une tâche i ne soit traitée par une machine, cette
dernière est immobilisée pendant une certaine durée pour effectuer le montage. Cette
durée ne dépend que de la tâche i et est notée S .i

les temps de démontage. A la fin du traitement d’une tâche i, cette dernière nécessite


40
un temps pour qu’elle soit démontée de la machine. Ce temps ne dépend que de la tâche
en question et est noté R .
i

Dans une large partie de travaux de recherche sur les problèmes d’ordonnancement avec consi-
dération des temps de préparation, les tâches sont classées en un nombre de familles. Chaque
famille est composée d’une ou de plusieurs tâches. Dans ce cas, les temps de préparation ne sont
considérés qu’entre deux tâches de familles différentes. Lorsque deux tâches de la même famille
sont ordonnancées successivement, le temps de préparation est supposé faire partie du temps de
traitement ; ainsi ce temps est ignoré et est égal à zéro. On trouve également des travaux dans
la littérature qui utilisent les notions des temps de préparation majeurs et mineurs (Major and
Minor setup times) [106].
◦ les temps de préparation majeurs. Il s’agit d’un temps de préparation nécessaire entre
deux tâches de familles différentes, noté maj (on n’utilise cette notation que dans les cas où
on considère les temps de préparation minor).
◦ les temps de préparation mineurs. Il s’agit du temps de préparation nécessaire entre
deux tâches de la même famille (noté min).
La littérature montre que plusieurs chercheurs s’interessent aux problèmes d’ordonancement
avec considération de différents types des temps de préparation. Citons par exemple, Allahverdi
et al. [7] qui ont fourni un examen complet de la littérature pour les problèmes d’ordonnancement

traitant ce sujet. Ils ont proposé une classification de problèmes en deux sous catégories : avec
lotissement (batch) et sans lotissement (non batch). Pour les deux catégories, les temps de prépa-
ration peuvent être indépendants ou dépendants. La classification proposée est présentée dans la
figure 2-1.
Le problème traité le plus basique est celui de 1 S ,j Cmax qui est équivalent au problème
| i |

de minimisation des temps de préparation 1 S . Ils sont, à leur tour, mathématiquement


|| i,j

équivalents au problème de voyageur de commerce (PV C ou TSP en anglais). Il s’agit d’un


voyageur de commerce qui doit visiter N villes données en passant par chaque ville exactement
une fois. Il commence par une ville quelconque et termine en retournant à la ville de départ. Les
distances entre les villes sont connues. Il doit faire le parcours en minimisant la distance parcourue.
Ce problème est connu d’être NP − Difficile. Pendant des années, les chercheurs s’efforcent à
41
Problèmes d’ordonnancements
avec
considération de setup

Batch Non-batch

Setup Setup Setup Setup


indépendant de la séquence dépendant de la séquence indépendant de séquence dépendant de la séquence

F . 2-1: Les problèmes d’ordonancement avec prise en compte de temps de préparation

chercher d’efficaces solutions pour résoudre ce problème. Citons par exemple les travaux de Lawler,
Lenstra, Kan, and Shmoys [92] ou Reinelt [128]. Les méthodes employées peuvent être adaptées
directement sur le problème en remplaçant les villes par les tâches et la matrice des distances entre
les villes d par la matrice S des temps de préparation entre les tâches.
i,j i,j

Ragatz [126] a étudié le problème d’ordonnancement sur une seule machine pour minimiser
le retard total avec considération des temps d’installation (1 S T ). Ce problème est NP − | i,j | i

Difficile au sens fort et présente plusieurs difficultés pour être résolu. Une borne inférieure a
été développée et utilisée dans un algorithme de séparation et d’évaluation (Branch-and-bound).
Une propriété de dominance a été établie pour réduire l’espace de recherche des solutions. Ragatz
a traité aussi le même problème avec Rubin [127] en appliquant les algorithmes génétiques. Ces
algorithmes ont donné de bons résultats en comparant avec l’algorithme de branch and bound
même s’ils ne donnent aucune garantie sur l’optimalité de leurs solutions.
Tan et Narasimhan [153] ont utilisé le recuit simulé pour résoudre le même problème. Cette
méthode est bonne pour des problèmes de grande taille.
Tan et al. [154] ont fait la comparaison entre quatre méthodes utilisées dans la littérature :
la branch and bound, les algorithmes génétiques, le recuit simulé et le “random-start pairwise
interchange”.
Rabadi [124] a traité le problème d’ordonnancement sur une seule machine pour minimiser la
somme des retards. Ce problème est connu sous le nom de “Juste à Temps” (just in time ) avec
une seule date de livraison commune pour toutes les tâches. Il a résolu le problème en utilisant

42
deux approches : la programmation en nombres mixtes et la programmation par contrainte. La
programmation par contrainte paraît plus efficace et plus flexible. Le même problème a été traité
par Rabadi et al. [125]. Ils ont utilisé une heuristique SAPT (shortest adjusted processing time)
et ont utilisé le recuit simulé SA. Ensuite, ils ont proposé une heuristique hybride SAPT − SA
dérivée des deux méthodes. Cette heuristique hybride donne des solutions de bonne qualité.
Nowicki et Zdrzalka [117] ont proposé une heuristique basée sur la recherche tabou. Cette
heuristique peut être appliquée pour minimiser n’importe quelle fonction objectif régulière sur
une seule machine (avec un temps de préparation majeur indépendant de la séquence et un temps
de préparation mineur qui prennent une valeur constante entre tous les sous-ensembles d’une
famille de tâches). Ils ont évalué leur heuristique dans le cas de minimisation du retard maximum
pondéré et du retard total pondéré.
Zdrzalka [168] a traité le problème d’ordonnancement des familles des tâches (batch) sur une
seule machine avec considération des temps de préparation indépendants de la séquence. L’utili-
sation du temps de préparation n’est considérée qu’entre deux tâches de deux familles différentes.
L’objectif de cette étude est de trouver l’ordonnancement qui minimise la date à laquelle l’ensemble
des tâches est livré. Il a précisé que ce problème est équivalent au problème de minimisation du
décalage temporel maximal (lateness) avec date de livraison modifiée. Il a fourni trois algorithmes
approchés qui garantissent des performances respectives au pire cas de (n − 1) , 2 et 3/2.
Zdrzalka [167] a prolongé ses travaux en traitant le même problème étudié dans [168] en consi-
dérant que les temps de préparation varient selon les familles (batch). L’utilisation du temps de
setup n’est considéré qu’entre deux tâches de deux familles différentes. L’auteur a utilisé deux
algorithmes à base de méthodes approchées. Les deux algorithmes proposés garantissent une per-
formance au pire cas qui ne dépasse pas le ratio 3/2.
En ce qui concerne le problème 1 r , S , pmtn Dtmax, Zdrzalka [169] a démontré qu’il est NP −
| i i |

Difficile. Il a également proposé une heuristique de complexité O(n log (n)) avec une étude de
performance au pire cas qui ne dépasse pas 3/2.
Dunstall et al. [49] ont étudié le problème de minimisation de la somme pondérée des dates de
fin d’exécution des tâches avec prise en considération des temps de préparation (1|Si , batch | w C ).
i i

Les tâches sont réparties en familles différentes. Ils ont proposé deux nouvelles bornes inférieures

43
qui dominent analytiquement celles proposées par Mason et Anderson [111]. Ces bornes sont utili-
sées dans un algorithme de séparation et d’évaluation qui peut résoudre des instances de 70 tâches
réparties en jusqu’à 15 familles. Monma et Potts [113] ont traité la minimisation de trois critères
à savoir le retard maximal, le nombre des tâches en retard et la somme pondérée des dates de fin
d’exécution des tâches. Pour ce dernier critère, ils ont développé une condition d’optimalité locale
et ont utilisé la programmation dynamique pour résoudre le même problème en O B 2N B2+B .
Cet algorithme peut être appliqué efficacement sur des instances de petit nombre de familles. Potts
et al. [12] ont ensuite adapté cet algorithme pour l’améliorer en O (N ) avec seulement deux fa-
3

milles. Ghosh [61] a utilisé aussi la programmation dynamique pour résoudre le même problème en
O B 2N B avec B le nombre des familles et N le nombre des tâches. Ce temps devient polynomial
en N pour un nombre de familles fixé.
D’autres algorithmes de séparation et d’évaluation ont été proposés par Mason et Anderson
[111] et par Crauwels et al. [38] pour le problème 1|Si , batch | en utilisant de fortes propriétés
wi Ci

de dominance issues des conditions d’optimalité connues. Ils ont utilisé la même structure que
l’algorithme de Mason et Anderson. En revanche, ils utilisent ces propriétés de dominance en les
associant à des bonnes bornes inférieures basées sur la relaxation lagrangienne du problème.
Crauwels et al. [38] ont proposé une gamme d’heuristiques basées sur la recherche locale pour le
problème 1 |Si , batch | wi Ci(multi-start descent, recuit simulé, threshold accepting et recherche
tabou). Par ailleurs, ils ont comparé les performances de ces heuristiques avec des résultats obtenus
par un algorithme génétique. Pour les problèmes de petit nombre de familles, la méthode de
recherche tabou est la meilleure. En revanche, pour les problèmes de grand nombre de familles,
l’algorithme génétique est plus performant.
Crauwels a également étudié, dans [37], une série d’heuristiques. Les tests numériques ont
montré que l’heuristique “multi-start descent” donne une performance supérieure en comparant
avec les algorithmes proposés dans la référence [38] incluant la recherche tabou pour des instances
supérieures à 100 tâches. Pour ce même problème, d’autres heuristiques de recherche locale ont
été aussi proposées par Baker [13] et Dunstall [48].
Dans [163], Williams et Wirth ont développé une heuristique pour le problème 1 |Si , batch | .
Ci

Cette heuristique ne peut garantir le respect de toutes les trois conditions majeures d’optimalité

44
pour le problème.
Liao C.-J. et Liao L.-M. [106] ont étudié le problème de minimisation du flowtime moyen
(mean flowtime) avec considération des temps de préparation majeurs et mineurs indépendants
de la séquence. Ils ont proposé des heuristiques basées sur une programmation dynamique de
sous-problèmes. Cette méthode a la capacité de résoudre plusieurs instances de ce problème avec
efficacité significative.
Le problème de minimisation des dates de fin d’exécution des tâches avec prise en compte des
temps de préparation dépendants de la séquence (1 S C ) a été montré NP − Diffi au
| i,j | i cile

sens fort. C’est également le cas du problème général 1 . Le problème 1


|Si,j | est
wi Ci |ri , Si | Ci

N P − Dif f icile puisque le problème sans temps de préparation l’est aussi [129].
Des méthodes heuristiques ont été proposées par d’autres chercheurs. Gupta [70] a proposé un
algorithme glouton pour résoudre le problème 1 atch w C en O (BN + N log (N )). La
| Si,j , b | i i

construction de l’heuristique se fait en sélectionnant à chaque itération une tâche parmi celles qui
ne sont pas encore ordonnancées et qui peut être achévée dans le plus bref délai. Il s’agit de la règle
de priorité du plus petit temps de traitement effectif SEPT (Shortest Effective Processing Time).
Pour une tâche non encore ordonnancée i de la famille B , le temps de traitement effectif pour
i

cette tâche est : p =S


i[B i ]ef f + p , avec B la famille de la dernière tâche ordonnancée
k[B k ],i[B i ] i[B i ] k

k.
Ahn et Hyun [6] ont étudié le problème 1 Ils ont montré que dans la séquence
|Si,j , batch| Ci .

optimale, les tâches appartenant à la même famille doivent être ordonnancées suivant la règle
SP T . Ils ont proposé, pour le même problème, une heuristique qui fournit une solution très
proche de l’optimum. Cette heuristique est presque similaire à celle proposée par Gupta [71] pour
ce problème, mais avec deux classes de familles des tâches. Le principe de l’heuristique est de
chercher un voisinage, à partir d’une solution courante, pour une éventuelle amélioration possible.
Une telle heuristique est un exemple de méthode de recherche locale et peut être classifiée dans la
classe des méthodes de descente.

45
2.3 Etude du problème 1 S | i,j | T i

Dans cette section, nous traitons le problème d’ordonnancement sur une seule machine avec la
considération des temps de préparation dépendants de la séquence. Le critère à optimiser est le
retard total (1 S
| i,j |T ). Nous commençons d’abord par un rappel bibliographique succinct sur
i

l’ordonnancement sur une machine en minimisant le retard total. Ensuite, nous présentons notre
approche de résolution et nous discutons les différents résultats numériques.

2.3.1 Minimisation du retard total sur une machine


Le problème de minimisation de la somme des retards a été largement étudié dans la littérature.
En effet, ce critère est important et répresente un indicateur fiable dans plusieurs cas industriels
(exemple : l’insatisfaction des clients et les coûts excessifs dus aux pénalités engendrées par les
retards).
On s’intéresse au problème de minimisation du retard total sur une seule machine 1 T . Ce
|| i

problème à été démontré NP −Difficile au sens ordinaire par Du et al. [47]. Smith [143] a proposé
des conditions d’optimalité locale pour ce problème. En 1982, Baker et Bertrand [12] ont proposé
une méthode heuristique dynamique qui s’est avérée efficace. Plusieurs méthodes exactes, utilisant
la programmation dynamique ont été proposées (Baker et Schrage [11] et Potts et Wassenhove
[122], [123]). Elles sont basées sur la décomposition du problème qui a été proposée précédemment
par Lawler [93]. D’autres méthodes de séparation et d’évaluation (Branch and Bound) ont été
proposées par Szwarc et al. [152]. L’approche de Szwarc et al. paraît particulièrement efficace ; elle
peut résoudre des instances de 300 tâches de taille.
D’autres travaux ont été consacrés au même problème mais avec des dates de disponibilité des
tâches (ou dates d’arrivée différentes). Il s’agit du problème 1 r T . Ce problème a été démontré
| i| i

NP − Difficile au sens fort [129]. Chu et Portman [36] ont proposé des conditions d’optimalité
locale. Chu a proposé également d’efficaces heuristiques, des propriétés de dominances et une borne
inférieure basée sur la règle SRP T (Shortest Remaining Processing Time) dans la référence [33].
Cette règle a été proposée par Schrage et Miller [137] en 1966. Elle donne la solution optimale
pour le problème de minimisation de flowtime total avec des dates de disponibilité différentes

46
en autorisant la préemption [138]. Le principe de cette règle peut être présenté comme suit.
A chaque instant où une nouvelle tâche devient disponible ou une tâche s’achève, on choisira
la tâche dont la durée opératoire (complète ou restante) est la plus courte. Ces propriétés de
dominance et les bornes inférieures ont permis de réduire considérablement l’espace de recherche
et l’occupation de mémoire (et en conséquence, le temps de calcul). En effet, l’algorithme de
séparation et d’évaluation proposé par Chu peut résoudre de difficiles instances jusqu’à une taille
de 30 tâches. Il peut également résoudre des problèmes de 230 tâches pour des instances faciles.
Récemment Baptiste et al. [15] ont réussi à mettre en oeuvre un algorithme de séparation et
d’évaluation qui peut résoudre de difficiles instances de 50 tâches. Il peut également résoudre des
problèmes de 500 tâches pour des instances faciles.

2.3.2 Problématique
Le problème est d’ordonnancer n tâches sur une machine. Pour chaque tâche i, i ∈ J =
{1 2
, }, on connaît la durée opératoire
,...,n (processing time ) et le délai de livraison (due
pi di

date ). Si on passe de la production du produit à celle du produit , il faut une intervention


i j

sur l’installation qui dure (setup time) unités de temps. Toutes les tâches sont disponibles à
Si,j

l’instant = 0. Soit la séquence avec = [0] [1] ème
t Q Q [n] Q [j ] ,Q ,...,Q et Q l’indice de la j tâche

dans la séquence. On a : Q[0] =0 ,j = 0 ∀j ≤ n


, S0 avec p0 = 0.
La date de fin d’exécution ( Completion time ) d’une tâche située dans la j ème position de la

séquence est donnée par l’équation 2.1.

CQ =
j SQ +p (2.1)
[j ] [i −1] ,Q[i] Q[i]

i=1

Le retard de la j ème tâche de la séquence est décrit dans l’équation 2.2.

TQ j [ ]
= max 0 ,C Qj[ ]
− dQ [j ]
(2.2)
L’objectif est de trouver la séquence Q qui minimise le retard total des tâches T (Q).

47
n
T (Q) = TQ
[i ]
(2.3)
i=1

2.3.3 Résolution par approche de séparation et d’évaluation

Pour résoudre le problème, nous allons construire une méthode de séparation et d’évaluation.
Cette méthode sera basée sur les bornes inférieures, les propriétés de dominance et les heuristiques
qui seront développées dans la suite. Dans ce paragraphe, nous donnons une description générale de
la structure de cette méthode. Cette dernière commence par l’application de quelques heuristiques.
La borne supérieure prendra initialement la meilleure des valeurs données par ces heuristiques.
Ensuite, notre méthode va opérer sur une structure de noeud. Chaque noeud est caractérisée par
les éléments suivants :
◦ une séquence partielle ,Q

◦ un niveau ,
k

◦ une borne inférieure LB (Q).


Chaque noeud de niveau dans l’arbre de recherche représente un séquence partielle de tâches
k

commençant par la tâche fictive 0. Désignons cette séquence par = [0] [1]
Q Q ,Q [k] (avec
, ..., Q

Q[0] = 0). Cette séquence peut être supprimée de la liste active si sa borne inférieure est supérieure
ou égale à la borne supérieure courante. Dans le cas contraire, nous séparons ce noeud en créant
les (n−k) séquences partielles possibles. Ces séquences partielles sont générées en affectant chaque
tâche, n’appartenant pas à Q, à la (k + 1) ème position dans la séquence. Si le noeud est terminal
i

(c’est-à-dire k = n), une mise à jour de la valeur de la borne supérieure est effectuée. Dans la suite,
nous présentons les principaux éléments de cette méthodes : les bornes inférieures, les propriétés
de dominance et les heuristiques utilisées.

2.3.4 Bornes inférieures

Dans cette section, nous nous intéressons à l’étape de l’évaluation d’un ordonnancement. Pour
ce faire, nous étudions de différentes possibilités de concevoir de bornes inférieures permettant
d’évaluer les solutions complètes émanant de la solution partielle. Nous présentons d’abord une
48
borne inférieure qui a été proposée par Ragatz. Ensuite, nous proposons une borne complémentaire
à celle de Ragatz en se basant sur la minoration des dates de début d’exécution de chaque tâche.

Borne inférieure de Ragatz LB1

Q[1] SQ[1] ,Q[2]


Q[ ]
2
...... Q[ k −1]
SQ [ k−1] ,Q[ k]
Q[k ]

SéquenceQ

F . 2-2: La séquence partielle Q

Etant donnée la séquence partielle Q =, cherchons une borne inférieure


Q[0] , Q[1] , . . . , Q[k ]

de la somme des retards des tâches qui ne sont pas encore ordonnancées (J − Q). Ragatz propose
de calculer une durée d’occupation de la machine nécessaire pour réaliser une tâche i ∈ (J − Q)
précédée d’un temps de setup. Cette durée se compose de deux termes :
◦ la durée opératoire p de la tâche i,
i

◦ la valeur minimale des temps de setups de la tâche Ψ (i) qui précèdera i et qui n’appartient
pas à l’ensemble Q[0] , Q[1] , . . . , Q[k−1] = Q
− :

SΨ(i) ,i = ∈(min
j − −
J Q )
{Sj,i } (2.4)

Ragatz propose de calculer la quantité pi pour chaque tâche i ∈ (J − Q) selon la formule


suivante :

pi = SΨ(i) ,i +p i (2.5)

La figure 2-3 illustre la considération proposée par Ragatz. Dans l’étape suivante, on classe la

suite {pi }i∈(J −Q) dans l’ordre croissant et on ordonnance des tâches fictives associées à ces durées

opératoires dans l’ordre correspondant. On obtient donc une suite {Ci }k +1≤i≤n qui représente les

49
S Ψ( ) i ,i
p i

p′ = SΨ
i ( i ),i
+p i

F . 2-3: Définition de pi

dates de fin d’exécution au plus tôt de différentes tâches de (J − Q). Ensuite, on trie la suite
dans l’ordre croissant. On obtient donc une nouvelle suite {di}k+1
{di }i∈(J −Q) i n
≤ ≤
. Enfin, la borne
de Ragatz se calcule selon la formule 2.6.
k n

LB (Q) =
1 TQ + [i]
max (0, C − d ) i i (2.6)
i=1 =k +1
i

avec Q
T le retard de la tâche qui se trouve à la position i dans la séquence partielle Q.
[i]

Notons que la borne de Ragatz se base sur un raisonnement similaire à celui qui a été proposé
par Chu [33] dans sa construction d’une borne inféreure pour le problème 1 r T . La borne | i| i

de Chu se base sur un ordonnancement préemptif Ω selon la règle (Shortest Remining S RP T

Processig Time). Cet ordonnancement permet d’avoir un vecteur (Ω) = { [ Ω]} ≤n avec C [ Ω] C C i,
i
i,

la date de fin d’exécution de la tâche à la ème position dans l’ordonnancement Ω. La borne de


i

Chu est donc calculable grâce à la formule suivante :

LBCHU = max (0, C [i, Ω] − d ) i


(2.7)
i

avec {d } ≤ la suite obtenue après classement de la suite {d } ≤ dans l’ordre croissant.


i i n i i n

La justification est basée sur le lemme suivant :


Lemme 1 (Chu [33]) Soient (x1 2 n) et ( 1
, x , .., x y , y2 , .., yn ) deux séries et soit (x1 , x2 , . . . , xn ) une

série ordonnée telles que 1/ x1 ≤ x2 ≤ ≤ n ... x , 2/ ∀i, xi ≤ xi . Si la série (y1, y2 , . . . , yn ) est

50
obtenue en classant la suite (y1 , y2, . . . , yn ) dans l’ordre croissant, la relation suivante est vérifiée :

n n

max (x − y , 0) ≤
i i max (x − y , 0)
i i (2.8)
i=1 i=1

Nouvelle borne inférieure LB2

Considérons la séquence Q déjà ordonnancée, et cherchons une borne inférieure en tenant


compte de Q. Il est clair que la tâche Φ Q k qui succèdera Q k (la dernière tâche ordonnancée
[ ] [ ]

dans la séquence Q) ne peut commencer qu’après un temps de setup minimal après la date de fin
d’exécution CQ k . Le temps de préparation minimal peut être calculé selon la formule 2.9.
[ ]

Smin Q[k = j ∈min


]
J −Q ( )
SQ k [ ] ,j
(2.9)

Il est clair que rk+1 = CQ k + Smin Q k


[ ] [ ] représente une date de début au plus tôt de la tâche

d’ordre (k + 1). Nous allons calculer une suite {ri }k+1≤i≤n qui représente une date de début au
plus tôt pour les tâches de (J − Q). Pour ce faire, nous allons calculer une durée nécessaire de
passage d’une tâche suivie d’un temps de setup. Cette durée est composée de deux termes :
◦ la durée opératoire p de la tâche i,
i

◦ la valeur minimale des temps de setup de la machine pour recevoir la tâche Φ (i) qui succèdera
i et qui n’appartient pas à Q :

S Φ( ) = ∈min−
i, i
j (J Q)
{Si,j } (2.10)

Nous calculons ensuite les quantités qi = p + S Φ( ). i i, i

La Figure 2-4 illustre une telle considération. Nous classons la suite {qi }i∈(J Q)

dans l’ordre

croissant, ce qui donne une suite {qi }k+1 ≤ ≤ i n . Nous pouvons ainsi obtenir une suite {rk+1 , rk +2 , . . . , rn }
de dates de début au plus tôt pour les tâches de (J − Q) avec r +1 = r + q
i i i (k + 1 ≤ i ≤ n − 1).
Or, en analysant la définition de la somme des retards pour un ordonnancement σ, nous pouvons
vérifier l’équation 2.11.
T (σ ) = i ∈J max (0, Ci (σ) − di ) = i∈J max (0, ti (σ) + pi − di)
51
p i
S Φ( i )
i,

q
i

F . 2-4: Définition de qi

T (σ) = max (0, ti (σ) − (di − pi)) (2.11)


i ∈J
avec t (σ) la date de début et C (σ) la date de fin de la tâche i dans l’ordonnancement σ.
i i

En posant d − p = ∆ , on obtient T (σ) = ∈J max (0, ti (σ) − ∆i)


i i i i . Or pour la suite

{ri }i=k+1 , et pour chaque ordonnancement possible σ de (J − Q), nous avons t[ ] (σ ) ≥ r


,...,n i i

∀i = k + 1, . . . , n. Il est clair qu’en classant les {∆ } ∈ J Q en {∆i}(k+1 i n) dans l’ordre crois-


i i { − } ≤ ≤

sant et en appliquant le lemme proposé par Chu [33] (cité précédemment), ont obtient une nouvelle
borne inférieure comme l’indique la formule suivante.
i= k n
LB2 (Q) = TQ +
[i]
max (0, r − ∆ ) i i (2.12)
i=1 =k+1
i

Remarque 2 Nous considérons dans tout le chapitre que di ≥p i pour tout i.

2.3.5 Propriétés de dominance


Dans cette partie, nous présentons trois règles de dominance. La première a été proposée dans
la littérature par Ragatz [126]. Elle est basée sur une comparaison de deux ordonnancements de
deux tâches successives i et j selon les deux cas possibles (j ≺ i ou i ≺ j )3 . La deuxième règle
généralise la première en considérant deux tâches i et j quelconques. La troisième règle consiste à
créer une séquence fictive associée à chaque séquence partielle et à voir ensuite, si cette dernière
est dominée par la séquence fictive.
3
i ≺ signifie que suit immédiatement
j j i.

52
Propriété de Ragatz [126]

On considère deux séquences S = {A,l, i,j, B} et S = {A, l, j, i, B} (voir figure 2-5) avec A
et B deux séquences partielles (elles peuvent être vides).

S:… pl Sl i,
pi Si j
,
pj Sj B , (1) …

C
l
Ci
C j

S’ : … p l
Sl , j p j
S j ,i p
i
Si B , (1) …

C′ = C
l l
C′ j
C′
i

F . 2-5: Illustration de la règle de dominance de Ragatz


L’idée de cette propriété de dominance est de trouver les conditions sous les quelles la séquence
S domine la séquence S´. La condition suivante : Sl,i + Si,j + Sj,m ≤ Sl,j + Sj,i + Si,m ∀ m = i, j, l est
necessaire pour que la séquence S domine la séquence S´. En effet, Il faut d’abord montrer que les
retards des tâches de la séquence B dans S´ sont au moins aussi grands que ceux dans la séquence
S . Cela est vrai si la date de début de la séquence partielle B dans S est inférieure ou égale à celle
dans la séquence S´.
Selon Ragatz, la séquence S domine la séquence S´si l’une des conditions qui suivent est vraie :
◦ Les deux tâches i et j ne sont pas en retard dans la séquence S .
◦ 2 (Sl,i − Sl,j ) + Si,j − Sj,i + pi − pj ≤ 0 lorsque i et j sont en retard dans la séquence S .

◦ dj − di − Sl,i + Sl,j + Sj,i − Si,j ≥ 0 lorsque seulement j est en retard dans la séquence S.
◦ Sl,j + pi + Sj,i ≥ Sl,i lorsque seulement i est en retard dans la séquence S .
En conclusion, pour n’importe quel noeud (dans la phase de séparation) qui représente une
séquence partielle se terminant par les tâches (l, j ), il est inutile de générer le noeud successeur qui
représente la séquence partielle se terminant par les tâches (l, j, i) si les tâches l, j , et i vérifient
l’une des quatre conditions précédentes.
53
i

l Sl, j
j

Séquence partielle

F . 2-6: Application de la règle de dominance de Ragatz


Nouvelle propriété de dominance 1

Soient S = S 0] [1][ ,S [k] et


,...,S = S 0] [1]
S
[[k] deux séquences partielles qui pos-
,S ,...,S

sèdent le même niveau k, contenant les mêmes tâches déjà ordonnancées et ayant la même dernière
tâche S k] = S[k] = K. Soient C (S ) et C (S ) les dates de fin respectives de K dans S et dans S . Les
[

variables T1 (S ) et T1 (S ) désignent les retards respectifs des tâches déjà ordonnancées dans S et S
(voir figure 2-7). S + et S + sont les séquences optimales des tâches non encore ordonnancées après
S et S . Soient T (S ) et T (S ) les retards totaux (lorsque toutes les tâches seront ordonnancées),
t t

c’est-à-dire T (S ) = T1 (S ) + T2 (S +) et T (S ) = T1 (S ) + T2 (S + ) avec T (S +) (respectivement


t t

T (S + )) le retard total des tâches qui appartiennent à la séquence S +(respectivement S + ).


Nous distinguons deux cas possibles :
◦ T1 (S ) < T1 (S ) Si C (S ) ≤ C (S ) ; donc S domine S (évident).
:

◦ T1 (S ) < T1 (S ) : Si C (S ) > C (S ) ;
au maximum T2 (S + ) ≤ T2 (S + ) + (n − k) (C (S ) − C (S ))
donc, T (S ) − T (S ) = (T1 (S ) − T1 (S )) + (T (S +) − T (S + ))
t t

≤ (T1 (S) − T1 (S )) + (n − k) (C (S ) − C (S ))
donc si (T1 (S ) − T1 (S )) + (n − k) (C (S ) − C (S )) ≤ 0 alors S domine S .

Nouvelle propriété de dominance 2


Considérons la séquence partielle = {A, i, j,K } avec A une séquence partielle (peut être
S
vide) et l représente la dernière tâche dans la séquence A. Supposons que K est la tâche qui doit

54
S S+

C (S )

S′ S ′+

C ( S ′)

F . 2-7: Séquences partielles S et S

être ajoutée lors de la séparation à la séquence partielle.


La propriété de dominance que nous allons décrire sera appliquée juste avant la phase de
séparation. Cette règle consiste à créer une séquence fictive S obtenue en permutant les deux tâches
i et j de la séquence S (S = {A, j, i, K }). Nous appliquons ensuite la propriété de dominance 1
pour voir si la séquence S est dominée strictement par la séquence S . Si c’est le cas, il est inutile
de faire la séparation et d’ajouter la tâche K à la séquence partielle.
On applique la dominance stricte car des solutions optimales peuvent être éliminées et perdues
(par exemple dans le cas où les deux séquences S et S se dominent mutuellement).

2.3.6 Heuristiques

Le choix de bonnes heuristiques pour la méthode de séparation et d’évaluation est très impor-
tant pour réduire le temps de calcul. Pour cela nous proposons quatre méthodes heuristiques pour
obtenir une bonne borne supérieure. Dans la suite, nous décrivons ces heuristiques.

55
S:… p
l
S l, i pi Si j,
pj Sj K
,
pK

C l
C i
Cj

S’ : … p l
Sl , j p j
Sj i ,
p i
SK
i,
pK

C′ = C l l
C′ j
C′ i

F . 2-8: Séquences S et S

◦ H1 : consiste à ordonnancer les tâches selon la règle EDD4 ,

◦ H2 : consiste à ordonnancer les tâches dans l’ordre croissant de ∆ =d −p


i i i,

◦ H3 :consiste à ordonnancer les tâches selon la règle MDD5 [12]. C’est une heuristique
constructive. A chaque étape i, on ordonnance la prochaine tâche h3[ ] parmi les tâches non i

encore ordonnancées U ( ) = − 3[0] 3[1]


i
3
[ −1]
J h ,h ,...,hi et qui vérifie :

   
min max Ch3[ −1] + pj , dj
j ∈U (i) i
= max Ch − + ph 3
[i 1]
3 , dh3
[i] [i]
(2.13)
◦ H4 : consiste à ordonnancer les tâches selon la règle MDD avec considération des temps
de setup. C’est une heuristique constructive. A chaque étape i, on ordonnance la prochaine

tâche h4[ parmi les tâches non encore ordonnancées U (i) = J − 4[0] 4[1]
i]
4
[ −1] h ,h ,...,h i et

qui vérifie :

 
min max Ch4[ −1] + Sh4[ −1] + p , d
j ∈U (i) i i
,j j j = max Ch − + Sh − 4
[i 1]
4 4
[i 1] ,h[i]
+ ph 4 , d h4
[i] [i]
(2.14)

4
Earliest Due Date.
5
Modified Due Date.

56
2.3.7 Résultats expérimentaux
Cette section est consacrée aux résultats expérimentaux. Nous analysons les performances des
bornes inférieures et des propriétés de dominance. Nous testons également l’effet de la stratégie
d’exploration utilisée au sein de la branch and bound. Le mode de génération des données testées
est présenté. Dans la suite, nous illustrons ces résultats et nous les commentons.

Performance de la borne inférieure [145]


Nous avons commencé les tests numériques par examiner la performance de la nouvelle borne
inférieure. Pour ce faire, nous avons construit un algorithme de séparation et d’évaluation. Cet
algorithme s’appuie sur les heuristiques et sur les bornes inférieures. Les règles de dominance n’ont
pas été implémentées dans cette première version. Afin d’examiner la qualité de notre nouvelle
borne inférieure, quelques séries d’exemples ont été testées. À chaque exemple, nous avons appliqué
l’algorithme de séparation et d’évaluation dans trois étapes. La première étape consiste à évaluer
les noeuds selon la borne inférieure de Ragatz. En second lieu, nous évaluons les noeuds en utilisant
notre borne inférieure. Enfin les deux bornes sont appliquées ensemble. Tous les exemples sont
aléatoirement générés par une distribution uniforme. Les séries employées pour les tests numériques
sont générées comme suit :
◦ Série 1 :
pi ∈ U [1, 10] ,
d ∈ U [p , 20 + p ] ,
i i i

S ∈ U [1, 20]
i,j avec S = +∞ i = j
i,j si .

◦ Série 2 :
p ∈ U [1, 10] ,
i

d ∈ U [p , 100 + p ] ,
i i i

S ∈ U [1, 100]
i,j Savec i,j = +∞ i = j
si .

◦ Série 3 :
57
pi ∈ U [1, 100] ,
di ∈ U [p , m]
i avec m= i pi ,

Si,j ∈ U [1, 20] avec S = +∞ si i = j .


i,j

Après la séparation d’un noeud, on doit choisir le prochain noeud à séparer. Ceci, se fait par
l’application de la politique d’exploration en profondeur d’abord et de choisir en cas d’égalité le
noeud qui possède la borne inférieure la plus petite, c’est-à-dire, IDBLBF (In Depth, the Best
Lower Bound First).
Les différents résultats sont récapitulés dans les tableaux 2.1 à 2.9. Dans ces tableaux, nous
avons utilisé les variables suivantes :
1) n : nombre des tâches,
2) nodes : nombre total des noeuds générés,
3) Best of : la meilleure solution obtenue avant l’arrêt du programme (le symbole “∗”

indique que le programme a été intérrompu à cause d’un problème de mémoire insuffisante),
4) Time(s) : le temps d’exécution du programme en secondes,

5) z : la moyenne par noeud de la différence entre les deux bornes inférieures avec z =
no LB2 no −LB1 no et no un noeud exploré.
( ( ) ( ))
nodes

T . 2.1: Résultats obtenus en utilisant la borne inférieure de Ragatz pour la série 1


n nodes Bestof Temps (s)
5 32 63 0,00
10 1132 260 0,03
15 4754 545 0,15
20 409829 939 19,07

Les différents résultats de simulation montrent l’efficacité de la nouvelle borne inférieure. Pour
les instances testées, la valeur moyenne de la nouvelle borne inférieure est plus grande que celle
proposée par Ragatz. En effet, nous pouvons noter que la moyenne est positive dans la plupart
des cas (voir le tableau 2.3, 2.6 et 2.9). Notons que les deux bornes, dans le cas général, sont
58
T . 2.2: Résultats obtenus en utilisant la nouvelle borne inférieure pour la série 1
n nodes Bestof Temps (s)
5 37 63 0,00
10 822 260 0,02
15 4952 545 0,17
20 354392 939 16,58

T . 2.3: Résultats obtenus en utilisant les deux bornes inférieures pour la série 1

n nodes Bestof Temps (s) z


5 32 63 0,00 4,15
10 782 260 0,02 2,91
15 4952 545 0,09 -1,88
20 238963 939 11,23 6,28

complémentaires car on peut toujours construire des instances pour lesquelles cette borne domine
l’autre ou l’inverse. En outre, nous pouvons noter que le nombre des noeuds nécessaires pour
converger peut être réduit en combinant les deux bornes inférieures (pour la comparaison voir les
tableaux 2.1 à 2.9). Dans la suite, nous implémentons les deux bornes inférieures et nous prenons
toujours la plus grande valeur des deux bornes.

Effet de la stratégie d’exploration


Afin d’identifier la meilleure stratégie d’exploration, quelques séries d’exemples ont été testées.
Les deux bornes inférieures et les règles de dominance ont été appliquées. À chaque exemple de la
série testée, nous avons appliqué l’algorithme de séparation et d’évaluation avec quatre stratégies
d’exploration : S1, S2, S3 et S4. Ci-dessous, une description succinte de ces stratégies.

T . 2.4: Résultats obtenus en utilisant la borne inférieure de Ragatz pour la série 2


n nodes Bestof Temps (s)
5 37 159 0,00
10 769 489 0,02
15 6846 704 0,23
20 312165 1425 15,29

59
T . 2.5: Résultats obtenus en utilisant la nouvelle borne inférieure pour la série 2
n nodes Bestof Temps (s)
5 28 159 0,00
10 1139 489 0,02
15 5770 704 0,20
20 346293 1425 17,18

T . 2.6: Résultats obtenus en utilisant les deux bornes inférieures pour la série 2
n nodes Bestof Temps (s) z
5 25 159 0,00 18,00
10 607 489 0,04 -18,28
15 4943 704 0,18 20,75
20 223617 1425 11,11 26,56

◦ La première stratégie S1 consiste à explorer l’espace de recherche selon la règle IDBLBF


(In Depth, the Best Lower Bound First).
◦ La stratégie S2 consiste à explorer l’espace de recherche selon les étapes suivantes. D’abord,
nous appliquons la règle d’exploration IDBLBF pour n2 itérations (une itération corres-
pond à l’exploration d’un noeud). Ensuite, un ensemble de n arbres est obtenu (un arbre
correspond à un ensemble de noeuds d’un même niveau). A cet ensemble, on applique les
règles de dominance pour les différents niveaux afin de réduire le nombre des noeuds ac-
tifs. Finalement, la règle IDBLBF est appliquée aux différents arbres à partir du niveau
n jusqu’au niveau 1. L’inversion du sens de l’exploration vise à améliorer la valeur de la
borne supérieure dans la phase de séparation. On répète ce procédé avec la nouvelle borne
supérieure jusqu’à ce que tous les arbres soient vides.
◦ La troisième stratégie S3 consiste à explorer l’espace de recherche en suivant les étapes

T . 2.7: Résultats obtenus en utilisant la borne inférieure de Ragatz pour la série 3


n nodes Bestof Temps (s)
5 52 150 0,00
10 8307 217 0,09
15 2866196 1013* 67,00
20 2586777 490* 157,00

60
T . 2.8: Résultats obtenus en utilisant la nouvelle borne inférieure pour la série 3
n nodes Bestof Temps (s)
5 39 150 0,00
10 9709 217 0,14
15 2865664 1013* 95,00
20 2586825 413* 146,00

T . 2.9: Résultats obtenus en utilisant les deux bornes inférieures pour la série 3
n nodes Bestof Temps (s) z
5 39 150 0,00 8,10
10 6486 217 0,10 4,29
15 2868211 1013* 87,00 8,61
20 2588069 490* 121,00 2,32

suivantes. D’abord, nous appliquons la règle d’exploration IDBLBF pour n2 itérations. Un


ensemble de n arbres est obtenu. A cet ensemble, on applique les règles de dominance aux
différents niveaux afin de réduire le nombre des noeuds actifs. Finalement, la règle IDBLBF
est appliquée aux différents arbres à partir du niveau n jusqu’au niveau 1 et ceci tant que
tous les arbres ne sont pas supprimés.
◦ La quatrième stratégie S4 consiste à explorer l’espace de recherche en largeur d’abord (Width
exploration) et d’appliquer les règles de dominance après chaque phase de séparation.
Pour tester ces stratégies, cinq séries d’instances ont été générées aléatoirement. La loi de
distribution utilisée est la loi uniforme. Les séries I1, I2, I3, I4 et I5 ont été générées pour des
tailles n appartenant à [5, 31] comme suit :
◦ La série I1 est caractérisée par : p ∈ [1, 60] , d ∈ [1, m + (n − 1) · 15] , S ∈ [1, 20] avec
i i i,j

m= p i i.

◦ La série I2 est caractérisée par : p ∈ [1, 100] , d ∈ [1, m + (n − 1) · 15] , S ∈ [1, 100] .
i i i,j

◦ La série I3 est caractérisée par : p ∈ [1, 30] , d ∈ [1, m + (n − 1) · 15] , S ∈ [1, 30] .
i i i,j

◦ La série I4 est caractérisée par : p ∈ [1, 40] , d ∈ [1, m + (n − 1) · 15] , S ∈ [1, 20] .
i i i,j

◦ La série I5 est caractérisée par : p ∈ [1, 50] , d ∈ [1, m + (n − 1) · 15] , S ∈ [1, 25] .
i i i,j

61
les différents résultats sont récapitulés dans les tableaux 2.10 et 2.10. Pour chaque taille de
problème et pour chaque stratégie d’exploration, on donne trois indicateurs de performances :
◦ la meilleure solution obtenue avant l’arrêt du programme (le symbole étoile “∗” indique que
le programme a été intérrompu à cause d’un problème de mémoire insuffisante),
◦ le temps d’exécution du programme,
◦ le nombre total des noeuds visités.

Les différents résultats de simulation montrent l’efficacité de la troisième stratégie. En effet,


parmi les stratégies étudiées, nous pouvons noter que la troisième stratégie présente les meilleures
performances (pour la comparaison, voir les tableaux 2.10 et 2.11). Cette stratégie représente le
bon compromis pour exploiter les meilleures performances à partir de la règle IDBLBF et des
règles de dominance. Ce choix a été motivé par le fait que la nouvelle propriété de dominance
ne peut être exploitée qu’en largeur ce qui rend l’exploration IDBLBF non adaptée. D’autre
part, l’exploration en profondeur a l’avantage de pouvoir mettre à jour la borne supérieure ce
qui accélère la résolution du problème. Nous concluons donc que le cumul des deux avantages
peut considérablement faciliter les choses. Nous avons donc construit cette stratégie d’exploration
dans cette optique. Les résultats obtenus montrent bien l’adéquation de ce choix au problème à
résoudre.

Etude de l’apport des propriétés de dominance


Pour tester la performance de nouvelles propriétés de dominance proposées, les mêmes séries I1,
I2, I3, I4, I5 ont été testées en utilisant deux programmes (avec un nombre des tâches n variant entre
5 et 31). Dans le premier programme, nous appliquons uniquement la propriété de dominance de
Ragatz. Dans le deuxième programme, nous appliquons toutes les propriétés de dominance. Pour
les deux programmes, nous appliquons la meilleure stratégie d’exploration trouvée (c’est-à-dire
la troisième stratégie). Les deux bornes inférieures ont été également utilisées. Dans cette étude
expérimentale, deux indicateurs de performance ont été étudiés : le nombre des noeuds visités et le
temps de calcul nécessaires pour atteindre la solution optimale. Les différents résultats comparatifs
ont été présentés dans les figures 2-9 et 2-10. Nous pouvons clairement remarquer que les nouvelles
62
propriétés de dominance apportent une amélioration aux indicateurs de parformance en comparant
avec la propriété de Ragatz. Ce résultat est bien vérifié pour toutes les tailles des problèmes.

Performances des propriétés de dominance: nombre des noeuds

1000000
nombre des noeuds
Nombr des noeuds

800000 : propriété de
dominance de
600000 Ragatz
nombre des noeuds
400000
: toutes les
200000 propriétés de
dominance
0 n
1 3 5 7 9 11 13 15 17 19 21 23 25 27
n

F . 2-9: Comparaison des nombres des noeuds

Performances des propriétés de dominance : temps de calcul

1600
1400 temps de calcul :
temps de calcul

propriété de
1200
dominance de
1000
Ragatz
800 temps de calcul :
600 toutes les propriétés
400 de dominance
200
0 n
1 3 5 7 9 11 13 15 17 19 21 23 25 27
n

F . 2-10: Comparaison des temps de calcul

2.4 Conclusion

Ce chapitre a été consacré à l’étude d’un cas important avec indisponibilité dépendante. Il s’agit
de la minimisation de la somme des retards sur une machine soumise à des temps de préparation

63
dépendants de la séquence. Après un rappel bibliographique concernant les travaux ayant abordé
ce type de problèmes, nous avons proposé une méthode de résolution exacte. Nous nous sommes
basés sur deux bornes inférieures, quelques propriétés de dominance et plusieurs heuristiques
classiques. Nous avons envisagé plusieurs stratégies d’exploration et nous avons sélectionné la plus
performante. Les résultats obtenus améliorent ceux de la littérature (méthode de Ragatz). Dans
la suite, nous présentons deux applications dans la continuité de cette étude.

64
T. 2.10: Résultats en moyenne obtenus : stratégies 1 et 2
S1 S2
n Bestof Temps (s) Nodes Bestof Temps (s) Nodes
5 76 0,00 19 76 0,00 19
6 150 0,01 29 150 0,01 29
7 25 0,00 9 25 0,01 9
8 92 0,04 48 92 0,01 48
9 41 0,01 69 41 0,01 69
10 50 0,02 175 50 0,04 181
11 89 0,06 223 89 0,04 328
12 62 0,05 427 62 0,05 383
13 127 1,39 9631 127 1,66 8461
14 135 2,02 10951 135 2,24 7024
15 316 14,94 62620 323 54,01 50124
16 403 2,82 9377 403 3,98 10935
17 591 94,86 251611 712 84,86 28597
18 247 29,58 70773 285 20,01 17603
19 387 37,29 69456 375 19,18 8909
20 127 44,10 69466 164 19,47 8777
21 650 275,84 360732 580 105,60 75086
22 233 97,04 110208 352 88,12 62331
23 239 48,18 62330 230 47,42 60095
24 1146 431,11 454258 1200 163,68 101274
25 716 282,63 307607 739 233,82 251339
26 447 88,99 79222 447 90,730 76969
27 709 195,657 127088 709 192,64 107627
28 1119 597,82 358069 1199 549,18 335800
29 251 141,10 62229 343 94,88 38404
30 1387 526,79 323750 1387 481,68 272709
31 638 89,60 53590 638 102,91 60554

65
T. 2.11: Résultats en moyenne obtenus : stratégies 3 et 4
S3 S4
n Bestof Temps (s) Nodes Bestof Temps (s) Nodes
5 76 0,00 19 76 0,00 27
6 150 0,01 29 150 0,00 49
7 25 0,01 9 25 0,00 14
8 92 0,02 48 92 0,02 91
9 41 0,01 69 41 0,01 112
10 50 0,03 177 50 0,05 222
11 89 0,03 275 89 0,11 400
12 62 0,050 391 62 0,12 531
13 127 1,50 9825 162 58,76 3502
14 135 1,87 9799 200 16,84 664
15 316 15,22 62886 386 83,65 3972
16 403 2,87 9065 501 23,12 2690
17 591 95,04 236538 835 84,98 5229
18 247 25,53 61921 357 17,25 3415
19 387 32,11 61733 436 17,69 2624
20 127 39,28 61762 226 17,51 1640
21 679 243,99 318044 727 90,02 9456
22 313 69,20 80383 512 68,35 10369
23 239 40,31 51805 392 18,72 3440
24 1162 345,85 305067 1210 93,39 14001
25 716 210,00 225935 880 95,12 15787
26 447 71,59 60524 488 97,78 17918
27 709 158,53 94075 722 111,22 20040
28 1157 406,97 196220 1272 116,20 22111
29 251 61,20 28272 383 46,21 10442
30 1451 300,53 187325 1550 126,44 27119
31 638 54,67 32342 719 26,13 7342

66
Chapitre 3

Autres applications du problème


1|Si,j | Ti

Dans le chapitre précédent, nous avons proposé une branch and bound pour résoudre le problème
1|S | T . Des applications à d’autres problèmes découlent de résultats établis. Ce chapitre sera
i,j i

donc consacré à présenter deux applications possibles. D’une part, nous considérons le problème
1|S | C . D’autre part, nous abordons le problème P |S | T et nous montrons comment
i,j i i,j i

adapter les résultats précédents pour ces deux applications.1

3.1 Etude du problème 1 S | i,j | Ci


Le problème de minimisation de la somme des dates de fin d’exécution des tâches sur une
machine a été bien étudié dans la littérature. Plusieurs travaux ont été ménés par les chercheurs
pour résoudre de différentes variantes. Dans ce paragraphe, nous allons rappeler les principales
études.
Dans sa version basique, ce problème à une seule machine (1 C ) peut être résolu opti-
|| i

malement par la règle SP T. Le même problème avec des dates d’arrivée des tâches différentes
(1 r
| i| C ) est NP − Difficile au sens fort [104]. Une synthèse biliographique a été établie par
i

Schmidt [135] sur le problème de minimisation du flowtime total avec considération d’un temps
1
Ce chapitre a fait l’objet des publications [147], [148], [150] et [146].

67
d’indisponibilité de la machine (temps alloué pour la maintenance de la machine) sur une ou
plusieurs machines. Ce type de problèmes sera abordé en détails dans la deuxième partie de ce
mémoire.
Ahmadi et Bagchi [5] ont comparé six bornes inférieures de la littérature pour le problème de
minimisation de flowtime total avec des dates d’arrivée différentes. Ils ont montré que la meilleure
borne est basée sur la relaxation du problème en autorisant la préemption et sur l’application de
la règle S RPT (Shortest Remaining Processing Time). Cette règle donne une solution optimale
pour le problème préemptif.
Dessouky and Deogun [44] ont traité le problème de minimisation du flowtime total pondéré
avec des dates d’arrivée différentes. Ils ont établi plusieurs propriétés de dominance. Ils ont proposé
également de partitionner le problème en sous problèmes. A chacun de ces sous-problèmes, il ont
appliqué un algorithme de séparation et d’évaluation (branch and bound). Leur méthode utilise
les deux rêgles ECT et EST comme bornes supérieures. La déviation moyenne de la règle ECT
par rapport à la solution optimale est moins de 3% pour tous les problèmes. L’algorithme peut
résoudre des problèmes jusqu’à une taille de 50 tâches.
Chu [32] a élaboré un algorithme de séparation et d’évaluation (Branch and bound). Il a
utilisé les règles PRTF (Priority Rule for Total Flow time) et APRTF (Alternative Priority Rule
for Total Flow time) comme bornes supérieures. Des propriétés de dominance ont été également
proposées avec l’utilisation d’autres propriétés déjà existantes dans la littérature ( [44], [20] et
[43]).
Chu a également proposé deux heuristiques basées sur ces règles et a analysé ses performances
au pire cas. Les résultats expérimentaux montrent que les heuristiques étudiées sont de bonne
qualité. Sa méthode peut résoudre des problèmes de 100 tâches de taille [31].
Récemment, Della Croce et T’kindt [41] ont proposé une amélioration de la borne SRPT .
Toutefois, la complexité de leur borne semble plus élevée que celle de la borne SRPT . En consé-
quence, elle n’améliore pas significativement la meilleure performance atteinte pour ce problème
dans la littérature.
Dans la suite de cette section, nous allons considérer le problème de minimisation de la somme
des dates de fin d’exécution sur une seule machine avec des temps de préparation dépendants.

68
Nous allons proposer une démarche similaire à celle élaborée pour résoudre le problème du chapitre
précédent.

3.1.1 Problématique
Le problème est d’ordonnancer tâches sur une machine. Pour chaque tâche de =
n i J

{1 2
, ,...,n }, on connaît la durée opératoire (processing time ). Si on passe de la production
pi

du produit i à celle du produit j , il faut un temps de préparation qui dure S (setup time) unités i,j

de temps. Toutes les tâches sont disponibles à l’instant t = 0.


Soit la séquence Q, Q = Q 0] [1]
[ ,Q [n] avec [j ] l’indice de la
,...,Q Q
ème tâche dans la séquence.
j

On a : [0] = 0, 0,j = 0 et 0 = 0. Le temps d’accomplissement (Completion time ) d’une tâche


Q S p

située dans la j ème position de la séquence est donné par l’équation 3.1.

CQ =[j ]
SQ [i −1] ,Q[i] +p Q[i] (3.1)
i=1

L’objectif est de trouver la séquence Q qui minimise la somme des dates de fin d’exécution des
tâches (flow time) C (Q).
n
C (Q) = CQ [i]
(3.2)
i=1

3.1.2 Description de la méthode proposée


Le problème étudié correspond à un cas particulier du problème 1 S T si on prend toutes
| i,j | i

les dates dues égales à 0. En conséquence, on peut reprendre plusieurs résultats établis dans
le chapitre précédent pour résoudre ce nouveau problème. Ainsi, nous proposons une méthode
de séparation et d’évaluation qui reprend le même schéma que celui utilisé dans la résolution
de 1 S| T . La méthode opère donc sur une structure d’arbre. Cet arbre regoupe les noeuds
i,j | i

qui caractérisent les ordonnancements en construction. A chaque noeud, on associe une séquence
partielle Q, un niveau k et une borne inférieure LB (Q) (voir chapitre précédent).
Comme toute méthode de séparation et d’évaluation, l’approche que nous proposons est basée
sur des bornes inférieures, des propriétés de dominance et des heuristiques. Dans la suite, nous

69
donnons une description de ces éléments.

Bornes inférieures
Les deux considérations du chapitre précédent restent valables. Etant donnée la séquence par-

tielle Q = Q 0] [ , Q[1] , . . . , Q[k ] , nous pouvons calculer une borne inférieure pour les tâches qui
ne sont pas encore ordonnancées de (J − Q). On propose de calculer la durée d’occupation de la
machine nécessaire pour réaliser une tâche i ∈ (J − Q) précédée d’un temps de setup. Cette durée
se compose de deux termes :
◦ la durée opératoire p de la tâche i, i

◦ la valeur minimale des temps de setups de la tâche Ψ (i) qui précèdera i et qui n’appartient
pas à l’ensemble Q 0] , Q[1] , . . . , Q[k−1]
[ = Q
− :

SΨ(i)
,i = ∈(min
j − −J Q )
{Sj,i } (3.3)

On calcule la quantité pi pour chaque tâche i ∈ (J − Q) selon la formule suivante :

pi = SΨ(i) ,i +p i (3.4)

Dans l’étape suivante, on classe la suite {pi }i∈(J −Q) dans l’ordre croissant et on les ordonnance
dans l’ordre correspondant. On obtient donc une suite {Ci }k+1≤i≤n qui représente les dates de fin
d’exécution au plus tôt de différentes tâches de (J − Q). La borne résultante se calcule selon la
formule 3.5.
k n
LB1 (Q) = CQ + [i]
C i (3.5)
i =1 i =k +1
avec CQ la date de fin d’exécution de la tâche i de la séquence partielle Q.
[i]

La deuxième considération est basée sur la tâche Φ Q k] qui succèdera Q[k] (la dernière tâche [

ordonnancée dans la séquence Q). Comme dans le chapitre 2, nous définissons le temps de prépa-
ration minimal dans la formule suivante 3.6.

70

Smin Q[k] = ∈min
J −Q j ( )
SQ k [ ] ,j
(3.6)
Nous définissons également la suite {r } +1≤ ≤ qui représente la date de début au plus tôt des
i k i n

tâches de (J − Q) en déterminant la valeur minimale des temps de setup pour recevoir la tâche
Φ (i) qui succèdera i et qui n’appartient pas à Q selon la formule :

S Φ( ) = ∈min−
i, i
j (J Q)
{Si,j } (3.7)

Nous calculons ensuite les quantités qi = p + S Φ( )


i i, i . Nous classons la suite {qi }i∈(J Q)

dans

l’ordre non décroissant, ce qui donne une suite {qi }k +1 ≤ ≤ i n.


Nous obtenons ainsi une suite {rk+1 , rk +2 , . . . , rn } des dates de début au plus tôt des tâches de
(J − Q) avec r +1 = r + q (k + 1 ≤ i ≤ n − 1). On peut, par la suite, avoir une deuxième borne
i i i

inférieure comme l’indique la formule suivante :


k n
LB2 (Q) = CQ +[i]
ri + pi (3.8)
i=1 =k +1
i ∈J −Q
i

Propriétés de dominance
Dans cette partie, nous présentons deux propriétés de dominance similaires à celles proposées
dans le chapitre précédent.

Propriété de dominance 1 Considérons deux séquences partielles S et S qui comportent les


mêmes tâches déjà ordonnancées et la même dernière tâche K. Soient C (S ) et C (S ) les dates de
fin respectives de K dans S et S . F1 (S ) et F1 (S ) sont les sommes des dates de fin des tâches
déjà ordonnancées dans S et S . On définie S + et S + comme les séquences optimales des tâches
non encore ordonnancées après S et S . Il est évident que S + = S + (car S et S se terminent par
la même tâche). Cette borne présente deux cas possibles :
◦ 1er cas : F1 (S ) ≤ F1 (S ). Dans ce cas, si C (S ) ≤ C (S ), alors S domine S (évident),
◦ 2ème cas :F1 (S ) < F1 (S ) C (S) > C (S )
. Dans ce cas, si (F1 (S ) − F1 (S )) + et si

(n − k ) (C (S ) − C (S )) ≤ 0 alors S domine S (k est le cardinal de S).

71
Propriété de dominance 2 Considérons la séquence partielle = {A,i, j, K } avec A une S
séquence partielle (peut être vide) et l représente la dernière tâche dans la séquence A. Supposons

que K est la tâche qui devrait être ajoutée lors de l’étape de séparation.

S:… pl Sl i ,
pi Si j
,
pj Sj K ,
pK

C
l
Ci
Cj

S’ : … p l
Sl j
,
p j
Sj i ,
pi Si K
,
pK

C′ = C
l l
C′ j
C′
i

F . 3-1: Séquences partielles S et S

La propriété de dominance que nous décrivons sera appliquée juste avant la phase de séparation.
Cette propriété consiste à créer une séquence fictive S obtenue par une permutation des deux
tâches i et j de la séquence S (c’est-à-dire S = {A, j,i, K }). Ensuite, nous appliquons la première
propriété de dominance pour voir si la séquence S est dominée strictement par la séquence S . Si
c’est le cas, il est inutile d’envisager ce cas de séparation et d’ajouter la tâche K dans la séquence.
On applique la dominance stricte pour la raison qu’il est possible que les deux séquences S et S se
dominent mutuellement et qu’elles contiennent chacune une solution optimale.

Heuristiques
Nous proposons cinq méthodes heuristiques pour obtenir une bonne borne supérieure. Ci-
dessous, la description de ces heuristiques.
◦ H1 : consiste à ordonnancer les tâches selon la règle S PT . 2

◦ H2 : consiste à ordonnancer les tâches selon la règle ECT avec considération du temps3

de préparation. C’est une heuristique constructive. A chaque étape i, on ordonnance la pro-


2
Shortest Processing Time
3
Earliest Completion Time

72
chaine tâche h2 parmi les tâches non encore ordonnancées (U ( ) = −
[i]
i J
2 2 2
h[0] , h[1] , . . . , h[i −1] ).

La tâche sélectionnée vérifie :

min Ch2[ −1] + Sh2[ −1] + p = Ch2 −1] + Sh2[ −1]


j ∈U (i) i i
,j j
[i i
,h
2
[i]
+p h
2
[i]
(3.9)
◦ H3 : consiste à ordonnancer les tâches selon la règle PRTF avec considération du temps de
4

préparation. Cette règle est inspirée de la règle P RTF proposée par Chu pour le problème
1r
| i| C . A chaque étape i, on ordonnance la prochaine tâche h3[ ] parmi les tâches non
i i

encore ordonnancées ( ( ) = − { 3[0] 3[1]


U i J
3
[ −1] }). La tâche sélectionnée vérifie :
h ,h ,...,h i

min Ch3[ −1] + 2 · Sh3[ −1] + p = C 3[ −1] + 2 · Sh3[ −1]


j ∈U (i) i i
,j j h
i i
,h
3
[i]
+p h
3
[i]
(3.10)
◦ H4 : ordonnancer les tâches selon la règle E ST avec considération du temps de prépara-
5

tion. A chaque étape i, on ordonnance la prochaine tâche h4[ parmi les tâches non encore i]

ordonnancées (U (i) = J − 4[0] 4[1] 4


[ −1] ) telle que :
h ,h ,...,h i

min Ch4[ −1] + Sh4[ −1]


j ∈U (i) i i
,j = Ch − + Sh −
4
[i 1]
4 4
[i 1] ,h[i]
(3.11)
◦ H5 : ordonnancer les tâches selon la règle APRTF avec considération du temps de prépara-
6

tion. A la date de fin de traitement de la tâche qui se trouve à la position (i − 1) la machine ,

devient disponible pour exécuter la tâche h5[ ] à la ième position. La tâche h5[i] appartient à l’en-
i

semble des tâches qui ne sont pas encore ordonnancées : (U (i) = J − h5[0], h5[1], . . . , h5[ −1] ). i

On sélectionne la tâche α et la tâche β vérifiant, respectivement, la règle EST et la règle


P RTF . Si α = β (α et β représentent la même tâche), on ordonnance la tâche h5 = α = β . [i]

Par défaut, c’est α qui sera ordonnancée avant. En revanche, on choisit β si Fαβ > Fβα et si
la formule 3.12 est vraie :

Fαβ − Fβα ≥ (card (U (i)) − 2)· max (tβ,α,r − tα,β,r ) (3.12)


r∈U (i)−{α,β }

4
Priority Rule for Total Flow time
5
Earliest Starting Time
6
Alternative Priority Rule for Total Flow time

73
avec Fαβ = Cα1 +Cβ1 Fβα = Cα2 +Cβ2 tα,β,r = Cβ1 +Sβ,r tβ,α,r = Cα2 + Sα,r (voir figure 3-2).
, , ,

L’équation 3.12 définit la comparaison entre le gain (Fαβ − Fβα) si on ordonnance β avant α
et la perte au pire cas qui ne peut dépasser (card(U (i)) − 2) maxr∈U (i)−{α,β} (tβ,α,r − tα,β,r ) · .

k Sk α ,
α Sα β,
β Sβ r
,
r

Cα Cβ 1 tα , β , r
S équence Q
1

k Sk β
,
β Sβ α,
α Sβ r
,
r
Cβ Cα 2 t β ,α , r
S équence Q
2

F . 3-2: Règle APRTF

Analyse au pire cas de l’heuristique Dans cette partie, nous analysons la perfor- P RT F

mance de l’heuristique au pire cas. Nous supposons que {1 2


P RT F } soit la séquence , ,...,n

obtenue en utilisant cette heuristique.


Ci = p + −=11 p + =2 (t − Cj−1)
i
i
j j t
i
j i i avec i la date de début d’exécution de .

= p + −=11 p + =2 S −1
i
i
j j
i
j j ,j

= =1 p + −1i
j =1 S +1 j
i
j j,j

∀ j < i 2S +1 + p ≤ 2S + p (selon la règle PRTF )


j,j j j,i i

S +1 ≤ 12 (p − p ) + S
j,j i j j,i

C ≤ =1 p + 12 −=11 (p − p ) + −=11 S
i
i
j j
i
j i j
i
j j,i

i-1 i

Ci-1 ti

F . 3-3: Séquence suivant la règle PRTF

74
= 12 i
j =1 (pi +p )+ j
−1 S
i
j =1 j,i

n
i=1 C ≤ 12
i
n
i=1
i
j =1
(pi + pj ) +
n
i=1
i
j =1
−1 S
j,i
n i−1
= 1
2
n
=1 i
i
· pi + i
j =1 pj + i=1 j =1 Sj ,i

= 1
2
n
=1 i
i
· pi + 1
2
n
i=1 j =1 pj
i
+ =1 n
i
−1 Sj
i
j =1 ,i

= 1
2
n
=1 i
i
· pi + 1
2 (n · p1 + (n 1) − · 2+p ... + pn ) +
n
i=1
−1 S
i
j =1 j ,i

= 1
2
n
=1 [i ·
i
pi + (n + 1 − i) · pi ] + n
i=1
i
j
−1 S
=1 j ,i

= n +1
2 =1 p
n
i i + n
i=1
i
j
−1 S
=1 j,i

Dans le cas où la matrice des temps préparation est symétrique, la quantité n=1 −=11 S est i
i
j j,i

indépendante de la séquence. C’est également le cas pour la quantité =1 p . On peut donc en n


i i

déduire dans ce cas que :

−1
C = n +2 1
n n n i

i p i + S j,i (3.13)
i =1 i=1 i=1 j =1

Résultats expérimentaux Nous avons implémenté notre méthode en intégrant les heuris-
tiques, les propriétés de dominance et les bornes inférieures. Pour fixer la stratégie adéquate
d’exploration, nous avons procédé à un test expérimental des quatre stratégies S1, S2, S3 et S4
déjà présentées dans le chapitre précédent. Ci-dessous, un rappel sur ces stratégies :
◦ La première stratégie S1 consiste à explorer l’arbre de recherche selon la règle IDBLBF (In
Depth, the Best Lower Bound First).
◦ La stratégie S2 consiste à explorer l’arbre de recherche en suivant les étapes suivantes.
D’abord, nous appliquons la règle d’exploration IDBLBF pour n2 itérations (une itération
correspond à l’exploration d’un noeud). Ensuite, un ensemble de n arbres est obtenu (cha-
cun de ces arbres représente un niveau allant de 1 à ). A cet ensemble, on applique les n

règles de dominance pour les différents niveaux afin de réduire le nombre des noeuds actifs.
Finalement, la règle est appliquée aux différents arbres à partir du niveau au
I DB LB F n

niveau 1 afin d’augmenter la valeur de la borne supérieure plus rapidement. Cette procédure
est répétée tant que tous les arbres ne sont pas vides.
◦ La troisième stratégie 3 consiste à explorer l’espace de recherche selon les étapes suivantes.
S

D’abord, nous appliquons la règle d’exploration pour 2 itérations. Un ensemble I DB LB F n

75
de arbres est obtenu. A cet ensemble, on applique les règles de dominance pour les différents
n

niveaux afin de réduire le nombre des noeuds actifs. Finalement, la règle est I DBLB F

appliquée aux différents arbres à partir du niveau au niveau 1 jusqu’à ce que tous les
n

arbres seront supprimées.


◦ La quatrième stratégie 4 consiste à explorer l’espace de recherche en largeur d’abord (width
S

exploration) et à appliquer les règles de dominance après chaque phase de séparation.


Ces stratégies ont été testées sur des instances générées aléatoirement selon une loi de distri-
bution uniforme. Les séries 1, 2, 3, 4 et 5 sont générées pour des tailles appartenant à [5 31]
I I I I I n ,

selon le descriptif suivant :


◦ La série I1 est caractérisée par : ∈ [1 pi , 100] , Si,j ∈ [1, 20] .
◦ La série I2 est caractérisée par : ∈ [1 pi , 20] , Si,j ∈ [1, 20] .

◦ La série I3 est caractérisée par : ∈ [1 pi , 50] , Si,j ∈ [1, 10] .

◦ La série I4 est caractérisée par : ∈ [1 pi , 100] , Si,j ∈ [1, 100] .

◦ La série I5 est caractérisée par : ∈ [1 pi , 20] , Si,j ∈ [1, 100] .

les différents résultats sont récapitulés dans les tableaux 3.1 et 3.2. Pour chaque taille de
problème et chaque stratégie d’exploration, on donne trois indicateurs de performance moyenne :
◦ la meilleure solution obtenue avant l’arrêt du programme,
◦ le temps d’exécution du programme,
◦ le nombre total des noeuds visités.
Les différents résultats de simulation montrent l’efficacité de la stratégie 3. En effet, cette S

stratégie présente les meilleures performances (pour comparaison, voir les tableaux 3.1 et 3.2).
Elle représente le bon compromis qui permet d’obtenir l’avantage de la règle d’IDBLBF et celui
des règles de dominance proposées. Les mêmes analyses du chapitre précédent démeurent valables.

3.2 Etude du problème P | S i,j | Ti


Dans cette section, nous traitons un problème plus général que le chapitre précédent. Il s’agit
de la minimisation de la somme des retards sur machines parallèles avec prise en compte des
76
temps de préparation dépendants. Nous commençons par un rappel bibliographique sur la mini-
misation des retards sur machines parallèles. Ensuite, nous présentons une méthode de séparation
et d’évaluation. Des résultats expérimentaux seront commentés et analysés.

3.2.1 Rappel bibliographique

Nous trouvons dans la littérature plusieurs travaux qui traitent les problèmes d’ordonnance-
ment sur machines parallèles identiques pour la minimisation de différents critères. En revanche,
le cas de minimisation de la somme des retards n’était pas très étudié dans la littérature pour
un certain temps. Ces dernières années, le problème a commencé à attirer l’attention de plusieurs
chercheurs.
Le problème (Pm T ) est considéré comme NP Difficile au sens ordinaire puisque
|| i −

Du et Leung [47] ont montré que le problème 1 T , qui est un cas particulier (m = 1), est
|| i

NP Difficile au sens ordinaire pour un nombre des machines fixe. D’ailleurs, Lawler [95], a

proposé un algorithme pseudo-polynomial pour le problème 1 T . Selon Lenstra et al. [104],


|| i

le problème est N P − Difficile au sens fort. Cependant, la complexité exacte (au sens fort ou
faible) de ce problème reste une question ouverte.
Les méthodes exactes pour ce problème sont généralement limitées aux cas spéciaux comme
Root [130] qui a considéré que toutes les tâches ont la même date de livraison. Il a présenté
un algorithme constructif pour réduire au minimum le retard total. Lawler [94], quant à lui, a
considéré que toutes les tâches ont la même durée opératoire et a formulé tout le problème de
retard comme un problème de transport. Elmaghraby et Park [50] ont développé un algorithme
de séparation et d’évaluation (branch-and-bound) pour réduire au minimum quelques fonctions
pénalisant les retards lorsque tous les poids des tâches sont égaux à 1. Ils ont considéré que les
durées opératoires et les dates de livraison sont les mêmes pour chaque tâche (p = d ) Plus tard,
i i .

Barnes et Brennan ont repris cette méthode et l’ont améliorée.


Une large classe des heuristiques utilisées, est basée sur les algorithmes de liste où les priorités
des tâches sont d’abord obtenues par une certaine règle. Ensuite, les tâches sont dispatchées
dans cet ordre à la machine qui garantit la date de fin au plus tôt. Une telle méthode a été
proposée par plusieurs chercheurs. Wilkerson et Irwin [162] ont développé une méthode, basée sur

77
la recherche locale, pour la minimisation du retard total sur une machine unique. Cette méthode
a été présentée par Baker [14] pour résoudre le cas des machines parallèles. Elle consiste à choisir
une tâche non encore ordonnancée selon la règle EDD et à l’affecter à une machine selon certaines
règles. Dogramaci et Surkis [46] ont proposé une liste d’heuristiques qui emploient trois règles de
priorité pour produire trois solutions différentes et puis choisir la meilleure solution. Ces règles
sont SPT , EDD et MDD. Dogramaci [45] a également présenté un algorithme de programmation
dynamique pour la minimisation du retard total. Ho et Chang [74] trient les tâches selon la règle
TRC (Traffic Congestion Ratio) et affectent les tâches sur les machines en utilisant des algorithmes
de liste de Dogramaci et de Surkis[46]. Dans l’article de Koulamas [90], une autre heuristique basée
sur la règle SPT a été proposée. Pour minimiser le même critère, il a proposé, dans son article
[89], une heuristique de décomposition et une heuristique de recuit simulé hybride. Alidaee et Rosa
[2] ont proposé une extension de la règle MDD de Baker et de Bertrand [12]. Cette méthode est,
selon l’expérimentation des auteurs, tout à fait efficace pour la minimisation du retard total et du
retard total pondéré sur machines parallèles.
Azizoglu et Kirca [9] ont proposé un algorithme de séparation et d’évaluation dans lequel ils
ont introduit des propriétés caractérisant la structure des séquences optimales avec une borne
inférieure efficace. Yalaoui et Chu [165] ont, également, proposé un algorithme de séparation et
d’évaluation pour la minimisation du retard total. Cet algorithme est basé sur quelques propriétés
de dominance et une borne inférieure.

3.2.2 Formulation du problème


Le problème est d’ordonnancer N tâches sur m machines parallèles identiques. Pour chaque
tâche i, i ∈ J = {1 2
, ,...,N} on connaît la durée opératoire (processing time ) et le délai de
, pi

livraison (due date ).


di

Un temps de préparation de durée (setup time) est nécessaire si une tâche précède une
Si,j i

tâche . Toutes les tâches sont disponibles à l’instant t = 0 (r = 0).


j i

On suppose que d ≥ p ∀i. Il est évident que si le nombre des tâches est inférieur à celui des
i i

machines, la solution optimale est obtenue en affectant à chaque machine une tâche. La valeur du
retard total est égale à 0 (d ≥ p ∀i), nous supposons donc que N > m.
i i

78
Machine 1 Q [ ] SQ
11 Q
1[1] , 1[ 2]
Q[ ]
12
.....
Q [n1 1 −1 ] SQ Q
1[ n1 −1] , 1[n1]
Q1[n ] 1

Séquence Q1
Q [ ] SQ Q Q[ ] .....
Q [n SQ Q2[ n2] Q [n ]
Séquence Q
Machine 2 21 2[1] , 2[2 ] 2 2 2 2 −1 ] 2[ n2 −1] , 2 2

Séquence Q2

Machine m Qm[1] SQ
m[1] ,Qm[ 2]
Qm[ ] 2
.....
Qm[n m −1]
SQ
m[ nm −1] ,Qm[ nm ]
Qm[n ]
m

Séquence Qm

F . 3-4: Définition de la séquence Q


Soit la séquenceQ = {Q1 2 m } qui regroupe l’ensemble des séquences Qk des différentes
,Q ,...,Q

machines k, telle que Qk = Qk 0] k[1] k[nk ] avec


[ ,Q k[j ] l’indice de la
ème tâche de la
,...,Q Q j

séquence sur la machine , = 1, 2, .. . , m et nk le nombre des tâches ordonnancées sur la machine


k k

k, 1 ≤ nk < N (voir figure 3-4). On a Qk 0] = 0 ∀k ≤ m, S0,j = 0 ∀ j et p0 = 0. [

La date de fin d’exécution d’une tâche située dans la j ème position d’une séquence sur la
machine k est donnée par l’équation 3.14.
i =j
CQk = [j ]
SQk [i −1] ,Qk[i] +p Qk[i] (3.14)
i =1
Le retard de la j ème tâche d’une séquence sur la machine k est décrit dans l’équation 3.15.

TQk j [ ]
= max 0 ,C Qk j [ ]
− dQk [j ]
(3.15)
Le retard total des tâches ordonnancées sur la machine k noté T (Qk ) est donné dans l’équation
suivante :
nk

T (Qk ) = TQk [i]


(3.16)
i =1
L’objectif est de trouver la séquence Q = {Q1 , Q2 , . . . , Q m} qui minimise le retard total des

79
tâches T (Q).
m
T (Q) = T (Qi ) (3.17)
=1
i

3.2.3 Description de la méthode proposée


L’approche proposée est une méthode de séparation et d’évaluation. Contrairement aux pro-
blèmes à une machine où la solution optimale correspond à une permutation, les problèmes avec
plusieurs machines n’obéissent pas toujours à cette règle. Dans le cas particulier des machines
identiques sans temps de préparation, l’ordonnancement optimal peut tout à fait être représenté
par une permutation. Dans ce cas, l’ordonnancement peut être généré en ordonnançant les tâches
(dans l’ordre de la permutation) sur la machine disponible au plus tôt.
Dans le cas des machines parallèles avec temps de préparation, cette règle est fausse. Néan-
moins, Schutten a récemment montré que cette règle peut être adaptée au problème des machines
parallèles identiques avec des temps de préparation [139].
Il faudrait dans ce cas ordonnancer les tâches (dans l’ordre de la permutation) en affectant la
prochaine tâche à la machine qui peut la terminer au plus vite [139].
En se basant sur ce résultat, nous allons donc construire notre schéma de séparation en utilisant
des séquences partielles d’une manière similaire à celle du chapitre précédent. La seule différence
consiste au fait qu’une tâche d’une séquence partielle est ordonnancée toujours sur la machine qui
minimise sa date de fin d’exécution et non pas sur la machine disponible au plus tôt.
Ainsi notre méthode opère sur une structure d’arbre formé de noeuds. Chaque noeud est
caractérisé par :
◦ une séquence partielle Q,
◦ un niveau k,
◦ une borne inférieure LB (k),
Dans la suite, nous présentons les bornes inférieures et les différentes heuristiques intégrées
dans notre branch and bound.

80
3.2.4 Bornes inférieures
Dans cette section, nous proposons deux bornes inférieures basées sur les mêmes principes
utilisés dans le deuxième chapitre dans le cas d’une seule machine. Cela permet d’évaluer les
séquences partielles des tâches et de décider de la suppression de certains noeuds et de l’exploration
des noeuds prometteurs. La première borne inférieure est basée sur la minoration de l’ensemble
des dates de fin d’exécution de chaque tâche. La deuxième borne est basée sur la minoration de
l’ensemble des dates de début de chaque tâche.

Première borne inférieure LBM1

Machine 1 l1

Séquence partielle Q1

l2
Machine 2
Séquence partielle Q2

.
.
.

Machine m lm

Séquence partielle Qm

F . 3-5: La séquence partielle Q


Soit la séquence partielle Q = {Q1 qui regroupe l’ensemble des séquences par-
, Q2 , . . . , Q m}
tielles Qk sur chaque machine k. lk représente la dernière tâche ordonnancée sur la machine k,
k = 1, 2, .. . , m. Soit l = card (Q) le nombre total des tâches ordonnancées et soit nk le nombre des
tâches ordonnancées sur la machine k (voir la figure 3-5). Nous allons chercher la borne inférieure
de la somme des retards des tâches qui ne sont pas encore ordonnancées (J − Q), notée LBM1.
On commence par le calcul d’une durée d’occupation de la machine nécessaire pour réaliser une
tâche i ∈ ( − ) précédée d’un temps de setup. Cette durée se compose de deux termes :
J Q

◦ la durée opératoire pi de la tâche , i

81
◦ la valeur minimale des temps de setups de la tâche Ψ ( ) qui précèdera et qui n’appartient i i

m} =
pas à l’ensemble − { 1 2
Q l ,l ,...,l
− Q :

SΨ(i) ,i = ∈(min
j− − J Q )
{Sj,i } (3.18)

On calcule la quantité pi pour chaque tâche i ∈ (J − Q) selon la formule suivante :

pi = SΨ(i) ,i +p i (3.19)

Dans l’étape suivante, on classe la suite {pi }i∈(J −Q) dans l’ordre non décroissant et on les affecte
dans l’ordre correspondant, sur toutes les machines une par une. On obtient donc m suites {Ci}
qui représentent des dates de fin d’exécution au plus tôt possibles de différentes tâches de (J − Q)
sur les différentes machines. On regroupe ces suites et on trie la série résultante et on ne garde
que les (N − l) petites valeurs qu’on note {C } +1≤ ≤N On trie également la suite {di}i∈(J −Q) dans
i l i
.

l’ordre croissant ce qui nous donne une suite {di}l+1≤i≤N . La borne résultante se calcule selon la
formule 3.20.
m N
LBM (Q) =
1 T (Qk ) + max (0, Ci − d )
i (3.20)
k=1 i=l+1

avec
k=m
k=1 T (Qk ) la somme des retards sur toutes les machines et T (Qk ) = ni=k1 TQk [i]
. Cette

borne répresente une extension de celle proposée par Yalaoui et Chu ([165]) pour Pm || T . i

Rappelons que les tâches de la séquence partielle Q sont ordonnancées selon la règle de Schut-
ten, c’est-à-dire, sur la machine qui minimise la date de fin de la tâche ordonnancée.
Nous pouvons également ordonnancer les {p } ∈(J −Q) dans l’ordre S PT sur la machine dispo-
i i

nible au plus tôt et considérer que la somme des dates de fin obtenues moins la somme des dates
dues des tâches non ordonnancées est une borne pour le retard total des tâches restantes. Dans
notre algorithme, la borne LBM1 tient compte de cette possibilité.

82
Machine 1 l1 min S
j∈( J −Q )
l1 , j

Cl1
rΦ ( )
1 l

Séquence partielle Q l1

Machine 2 l2 min S
j∈( J −Q)
l2 , j

. C l
2
rΦ ( l )
2
.
. Séquence partielle Ql2

Machine m lm min S
j∈( J − Q)
lm , j

C lm
rΦ ( l )
m

Séquence partielle Q lm

F . 3-6: Définition de rΦ(lk )

Deuxième borne inférieure LBM2


Considérons l’ensemble Q déjà défini précédemment (voir figure 3-5). Pour calculer la deuxième
borne inférieure LB M2 , nous allons chercher l’ensemble des dates qui represente une minoration

de l’ensemble des dates de début des tâches non encore ordonnancées. Il est clair que l’ensemble
des tâches {Φ ( 1) Φ ( 2)
l , l Φ ( m)} qui succèdera l’ensemble des dernières tâches ordonnancées
,..., l

sur chaque machine { 1 2 m } ne peuvent commencer qu’après un temps de setup minimal


l ,l ,...,l

après la date de fin d’exécution k k ∈ {1, 2, .. . , m}. Les temps de préparation minimale peuvent
Cl ,

être calculés selon la formule suivante 3.21 (voir figure 3-6).

Smin (lk ) = j∈min


J −Q
{Slk
( )
,j } (3.21)

Il est clair que rΦ(lk ) = C k + Smin (lk ) représente une date de début au plus tôt de la tâche qui
l

doit être ordonnancée juste après la tâche lk sur la machine k.


Pour les tâches de (J − Q) nous allons construire une suite de dates de début au plus tôt.
,

Pour ce faire, nous calculons pour chaque tâche i de (J − Q) la quantité q (déjà définie dans la i

section précédente) selon la formule :

83
qi = pi + Si Φ( )
, i avec Si, Φ( )
i = ∈min
j( − )
{S
J Q
i,j } (3.22)
On ordonnance donc des tâches fictives de longueur q sur chaque machine, une par une, dans
i

l’ordre SPT . Cela nous permet de construire m suites {r } qui représentent des dates de début
i

au plus tôt pour les tâches restantes de (J − Q) sur les machines.


Ainsi, en utilisant la deuxième formule du retard, (c’est à dire, T = max (0 − ( − )) pour i , ti di pi

chaque tâche de ( − ), nous allons pouvoir construire la deuxième borne inférieure. Il suffit
i J Q

donc pour cela de remplacer les par des (obtenus en triant l’ensemble des suites { } et en
ti ri ri

ne gardant que les ( − ) plus petites valeurs) et de trier les ∆ = − dans l’ordre croissant.
N l i di pi

Notons {∆ } ∈{ +1,l+2,...,N } la suite qu’on obtient après l’opération de tri. La borne inférieure se
i i l

calcule donc selon la formule :


m N
LBM2 (Q) = T (Qk ) + max (0, ri − ∆ ) i (3.23)
k =1 i=l+1
Q et T (Qk ) ont été définies précédemment.

3.2.5 Heuristiques

Pour obtenir une borne supérieure initiale, nous proposons quatre méthodes heuristiques. Ces
heuristiques sont les mêmes que celles utilisées dans le cas d’une seule machine. Chaque heuristique
nous donne une séquence des tâches sur une machine, le principe est d’affecter les tâches, une par
une, sur la machine qui lui garantira la date de fin d’exécution au plus tôt (règle de Schutten), tout
en respectant l’ordre de passage des tâches dans la séquence obtenue. Ensuite, nous apportons des
améliorations sur les séquences obtenues sur chaque machine par l’application d’un programme de
séparation et d’évaluation (pour une machine). Rappelons que les heuristiques utilisées sont les
suivantes :
◦ H1 : consiste à ordonnancer les tâches selon la règle E DD 7
,

◦ H2 : consiste à ordonnancer les tâches selon l’ordre non décroissant de ∆ = d −p


i i i,

7
Earliest Due Date.

84
◦ H3 : consiste à ordonnancer les tâches selon la règle MDD 8
.

◦ H4 : consiste à ordonnancer les tâches selon la règle MDD avec considération des temps de
setup.

3.2.6 Résultats expérimentaux


Afin d’examiner la qualité de la borne supérieure puis son amélioration par la procédure de
séparation et d’évaluation, nous avons testé quelques séries d’exemples. À chaque exemple, nous
avons appliqué l’algorithme de séparation et d’évaluation.
Les données sont générées aléatoirement suivant une loi de distribution uniforme. Nous avons
testé les problèmes avec un nombre de machines m = 2, 3, 4, 5 et 10. Le nombre des tâches varie
entre 5 et 50 (par pas de 5). Trois séries, employées pour les tests numériques, ont été générées
comme suit :
◦ Série 1 : pi ∈ U [1, 20] ,
◦ Série 2 : pi ∈ U [1, 50] ,

◦ Série 3 : pi ∈ U [1, 100].

Pour chaque série, on fait le test pour les différentes valeurs de Si,j ∈ U [1, 20] , U [1, 50] et

U [1, 100] avec di ∈ U 1, N ∗p+(N
m
−m)∗S
, p la durée opératoire moyenne et S le temps de setup
moyen.
Nous allons faire une comparaison de la valeur du retard total entre la meilleure solution
obtenue par les quatre heuristiques initiales notées BestH 1 = min( =1 2 3 4) {H } et la meilleure
i , , , i

solution obtenue après l’amélioration de ces heuristiques en appliquant la branch and bound à une
machine notée BestH 2 = min( =1 2 3 4) {BAB (H )} par rapport à la solution optimale BESTOF
i , , , i .

Les différents résultats sont récapitulés dans les tableaux (3.3, 3.5, 3.6 et 3.7). Chaque tableau
donne les valeurs moyennes du retrad total enregistré lors des tests sur une machine m = 2, 3, 4, 5
ou 10. Dans les colonnes nous utilisons les variables suivantes :
1) N : nombre des tâches,

2) BestH 1 : solution obtenue par la meilleure heuristique,

8
Modified Due Date.

85
3) BestH 2 : la meilleure solution obtenue par les heuristiques améliorées,
4) BESTOF : la meilleure solution obtenue avant l’arrêt du programme.

1800
1600
1400
1200
Retard total

1000 Best H1
800 Best H2
600 BESTOF
400
200
0
-200 0 10 20 30 40 50 60
N

F . 3-7: Comparaison des valeurs moyennes du retard total pour deux machines parallèles

D’après les courbes 3-7, 3-8, 3-9, 3-10 et 3-11, on constate que l’application de la branch
and bound à une machine améliore presque dans tous les cas la solution BestH 1 obtenue par la
meilleure des heuristiques.
Nous avons approfondi cette comparaison, c’est à dire, entre BestH 1 et BestH 2 afin de voir
l’impact sur les performances de notre algorithme. Pour ce faire, nous avons effectué des tests sans
et avec l’amélioration des heuristiques. Les courbes 3-12, 3-13, ??, 3-15, 3-16 et 3-17 représentent
les nombres moyens des noeuds générés et les temps moyens de calcul sans et avec amélioration
des heuristiques enregistrés lors des tests sur m machine (m = 2, 3, 4). Les différents résultats
de simulation montrent que l’amélioration de la borne supérieure à l’aide de la procédure de
séparation et d’évaluation est très éfficace. Nous pouvons remarquer facilement que le temps
d’exécution du programme devient très grand si on se contente de la borne supérieure initiale.
En conséquence, nous avons retenu cette amélioration des heuristiques. Notre algorithme a été
implémenté en intégrant les deux bornes inférieures. Les résultats obtenus sont très satisfaisants.

86
450
400
350
300

Retard total
250 Best H1
200 Best H2
150 BESTOF
100
50
0
-50 0 10 20 30 40 50 60

F . 3-8: Comparaison des valeurs moyennes du retard total pour trois machines parallèles

Notre algorithme permet de résoudre des problèmes d’une cinquantaine de tâches.

3.3 Conclusion générale

Dans ce chapitre, nous avons proposé deux applications des résultats que nous avons établis
pour le problème 1 S T dans le chapitre précédent. D’une part, nous avons étudié le problème
| i,j | i

1S
| C qui représente un cas particulier. D’autre part, nous avons généralisé l’approche au
i,j | i

problème P S | T . Nous avons montré comment adapter les résultats précédents pour ces deux
i,j | i

applications. Les résultats obtenus sont encourageants par rapport aux résultats de la littérature.
Dans ces deux derniers chapitres, nous avons considéré le cas où l’indisponibilité de la res-
source est liée à la séquence ordonnancée. Toutefois, le cas dépendant est récurrent dans le monde
industriel et dans le domaine de la maintenance en particulier. Il est donc important d’explorer
ce type de problématique. Cela fera l’objet de la partie suivante qui sera dédiée à l’étude de deux
cas d’indisponibilité indépendante.
87
300

250

Retard total 200

150 Best H1
Best H2
100 BESTOF
50

0
0 10 20 30 40 50 60
-50
N

F . 3-9: Comparaison des valeurs moyennes du retard total pour quatre machines

300

250

200
Retard total

Best H1
150 Best H2
BESTOF
100

50

0
0 10 20 30 40 50 60
N

F . 3-10: Comparaison des valeurs moyennes du retard total pour cinq machines parallèles

88
T. 3.1: Résultats moyens obtenus pour les stratégies 1 et 2
S1 S2
n Bestof Temps (s) Nodes Bestof Temps (s) Nodes
5 416 0.00 10 416 0.00 10
6 651 0.00 15 651 0.00 15
7 872 0.00 26 872 0.00 26
8 949 0.00 19 949 0.00 19
9 1242 0.00 42 1242 0.00 42
10 1487 0.01 88 1487 0.01 88
11 1860 0.01 91 1860 0.01 91
12 2034 0.03 247 2034 0.04 248
13 2298 0.08 516 2298 0.08 518
14 2770 0.13 672 2770 0.13 666
15 3341 0.23 998 3341 0.42 998
16 3870 1.01 3741 3870 1.04 3612
17 4273 0.65 1870 4273 0.68 1878
18 4819 0.76 1898 4819 0.80 1886
19 5644 3.67 7579 5644 3.93 7718
20 6137 6.31 10897 6137 5.20 8584
21 6698 21.48 31315 6698 25.37 28713
22 7186 16.24 17462 7186 10.96 12984
23 8113 44.95 51110 8113 50.63 31231
24 8290 34.32 31098 8290 37.84 29958
25 9092 84.46 63472 9092 92.15 56766
26 9627 231.80 146186 9627 140.87 66817
27 10049 206.48 124227 10049 206.33 110220
28 11001 347.29 184728 11002 242.05 110096
29 12312 542.99 258498 12302 364.65 188143
30 13425 568.10 259775 13467 422.83 197560
31 13871 598.85 235194 13859 455.51 175617

89
T. 3.2: Résultats moyens obtenus pour les stratégies 3 et 4
S3 S4
n Bestof Temps (s) Nodes Bestof Temps (s) Nodes
5 416 0.00 10 416 0.00 18
6 651 0.00 15 651 0.00 25
7 872 0.00 26 872 0.01 45
8 949 0.00 19 949 0.00 36
9 1242 0.00 42 1242 0.01 74
10 1487 0.03 88 1487 0.02 139
11 1860 0.01 91 1860 0.04 173
12 2034 0.03 247 2034 0.09 459
13 2298 0.08 485 2298 0.17 737
14 2770 0.14 666 2770 0.37 1181
15 3341 0.25 998 3341 0.63 1790
16 3870 1.00 3520 3870 23.48 5829
17 4273 0.64 1784 4273 1.72 2916
18 4819 0.79 1884 4819 1.96 3213
19 5644 3.70 7358 5664 61.73 8839
20 6137 6.13 10196 6152 90.20 9710
21 6698 21.34 30561 6731 93.98 10272
22 7186 13.36 16077 7231 61.04 10110
23 8113 43.90 43390 8151 80.88 11517
24 8290 33.52 29762 8290 79.22 15008
25 9092 81.85 60281 9158 106.40 16163
26 9627 228.95 142659 9645 110.83 18081
27 10089 206.71 121550 10104 115.64 20373
28 11009 302.23 159097 11052 119.04 22501
29 12312 310.21 155749 12371 129.17 24715
30 13433 308.64 144649 13561 137.27 27217
31 13702 332.47 131043 13966 155.06 30053

90
T. 3.3: Résultats obtenus pour deux machines (retard total)
N BestH 1 BestH 1 BESTOF
5 23 19 19
10 65 33 16
15 250 83 44
20 61 20 20
25 390 193 112
30 318 82 82
35 1588 84 84
40 17 1 1
45 819 117 114
50 74 15 15

T. 3.4: Résultats obtenus pour trois machines (retard total)


N BestH 1 BestH 1 BESTOF
5 29 26 21
10 27 24 10
15 67 63 25
20 47 33 20
25 129 75 75
30 140 51 51
35 405 106 106
40 2 1 1
45 117 44 44
50 35 15 15

91
T. 3.5: Résultats obtenus pour quatre machines (retard total)
N BestH 1 BestH 1 BESTOF
5 19 19 15
10 26 26 17
15 70 68 31
20 39 37 23
25 101 79 79
30 107 63 63
35 270 130 130
40 19 4 4
45 55 23 23
50 50 25 24

T. 3.6: Résultats obtenus pour cinq machines (retard total)


N BestH 1 BestH 1 BESTOF
10 37 37 19
15 60 60 49
20 46 42 35
25 80 75 75
30 104 69 69
35 241 158 158
40 31 13 13
45 12 7 7
50 32 13 13

T. 3.7: Résultats obtenus pour 10 machines


n BestH 1 BestH 2 BESTOF
15 60 60 40
20 45 45 30
25 61 61 49
30 49 45 41
35 91 81 81
40 30 28 28
45 35 29 29
50 20 18 18

92
100
90
80
70
Retard total 60 Best H1
50 Best H2
40 BESTOF
30
20
10
0
0 10 20 30 40 50 60
N

F . 3-11: Comparaison des valeurs moyennes du retard total pour dix machines parallèles

1400000

1200000

1000000

800000
Nodes

Best H2
600000
Best H1
400000

200000

0
0 10 20 30 40 50 60
-200000
N

F . 3-12: Comparaison des valeurs moyennes du nombre des noeuds pour deux machines

93
2000,00

1500,00
Temps (s)
1000,00
Best H2
Best H1
500,00

0,00
0 10 20 30 40 50 60

-500,00
N

F . 3-13: Comparaison des valeurs moyennes du temps de calcul pour deux machines

800000
700000
600000
500000
Nodes

400000 Best H2
300000 Best H1

200000
100000
0
0 10 20 30 40 50 60
-100000
N

F . 3-14: Comparaison des valeurs moyennes du nombre des noeuds pour trois machines

94
2000,00

1500,00
Temps (s)

1000,00
Best H2
Best H1
500,00

0,00
0 10 20 30 40 50 60

-500,00
N

F . 3-15: Comparaison des valeurs moyennes du temps de calcul pour trois machines

3500000

3000000

2500000

2000000
Nodes

Best H2
1500000
Best H1
1000000

500000

0
0 10 20 30 40 50 60
-500000
N

F . 3-16: Comparaison des valeurs moyennes du nombre des noeuds pour quatre machines

95
2000,00

1500,00
Temps (s)

1000,00
Best H2
Best H1
500,00

0,00
0 10 20 30 40 50 60

-500,00
N

F . 3-17: Comparaison des valeurs moyennes du temps de calcul pour quatre machines

96
Chapitre 4

Etude du problème 1, h1|| wiCi

Dans ce chapitre, nous considérons un cas d’indisponibilité indépendante. Le problème traité


est celui d’une machine avec une seule période d’indisponibilité. Le critère à optimiser est la
somme pondérée des dates de fin d’exécution. Nous proposons trois approches pour résoudre ce
problème : une branch and bound, un programme linéaire en nombres entiers et une programmation
dynamique. Des résultats comparatifs seront également présentés.1

4.1 Introduction

Les pannes des machines, qui interrompent la production, engendrent des coûts supplémen-
taires et mettent en danger la vie des opérateurs. Ces incidents peuvent être généralement évités
si la maintenance des installations est régulièrement effectuée. Aujourd’hui, cette maintenance est
exigée par plusieurs normes de qualité. Elle peut être planifiée par la mise en place des procédés
permettant une prévention rapide de pannes et en conséquence, d’éviter les coûts supplémentaires.
Négliger la maintenance préventive peut dégrader la performance de la machine en terme de pro-
ductivité, de précision, de vitesse et de consommation d’énergie. De plus, la transmission de la
défaillance à d’autres pièces de la machine en est une possible conséquence.
Il est donc important que les modèles d’ordonnancement prennent en compte les temps alloués
à la maintennace pour que ces modèles soient plus fiables et plus robustes. En effet, la non prise en
1
Ce travail a fait l’objet des publications [85] et [86].

97
compte de ces tâches de maintenance, peut fausser les actions et les décisions que les responsables
doivent prendre. Malheureusement, dans la littérature, la machine est considérée souvent comme
parfaite et n’a pas besoin d’entretien.
Dans cette optique, plusieurs chercheurs commencent à s’interresser à ce type de problèmes
ces dernières années (Aggoune [3] [4], Kubiak et al.[91], Sadfi [132], Lorigeon et al. [110]). On peut
distinguer deux cas d’étude d’indisponibilité de la machine : le cas déterministe et le cas stochas-
tique. Dans le cas déterministe, les périodes d’indispoibilité sont connues à l’avance. Ces périodes
d’indisponibilité peuvent être traduites par des maintenances préventives qui sont programmées
à l’avance. Dans le cas stochastique, les périodes d’indisponibilité se manifestent d’une manière
aléatoire (exemple : le cas d’arrêt de fonctionnement de la machine à cause d’une panne survenue).

4.2 Problèmes d’ordonnacement avec contrainte d’indis-


ponibilité de machine
Une synthèse biliographique a été établie par Schmidt [136] sur le problème de minimisation
du flowtime total avec considération d’une période d’indisponibilité sur une ou plusieurs machines.
Turkcan [156] a fourni aussi un état de l’art sur les mêmes problèmes (machine unique, machines
parallèles, flowshop) dans le cas déterministe et le cas stochastique. Dans la suite, nous rappelons
les travaux les plus importants dans le domaine.

4.2.1 C as d’une seule machine


Adiri et al [1] ont étudié le problème de la minimisation de la somme des dates de fin d’exécution
des tâches sur une seule machine. Une seule période d’indisponibilité a été considérée sur la
machine. Toutes les tâches sont disponibles à t = 0 et la préemption des tâches est interdite. Adiri
et al ont démontré que le problème est NP − difficile au sens ordinaire dans le cas déterministe.
Ils ont démontré que l’erreur relative de l’heuristique SPT est inférieure à 14 .
Lee et Liman [103] ont traité le même problème que celui de Adiri et al. Ils ont également étudié
ce problème dans le cas stochastique où les dates et les durées des périodes d’indisponibilité sont
aléatoires et inconues. Ils ont démontré que ce problème est NP −Complet, pour le cas déterministe
98
même avec une seule periode d’indisponibilité (avec une démonstration plus simple que celle de
Adiri et al [1]). Ils ont prouvé aussi que l’heuristique SPT donne une erreur relative atteinte de 27
(c’est à dire une garantie de performance au pire de 97 ). Ils ont appuyé leurs propos par un exemple
qui contredit le résultat trouvé par Adiri et al.
Dans [100], Lee a étudié des problèmes d’ordonnancement à une seule machine avec contrainte
d’indisponibilité pour optimiser d’autres critères. Il a traité le cas où la préemption est autori-
sée puis le cas où celle-ci est interdite. L’auteur a prouvé que n’importe quelle séquence pour le
problème 1 h1 pmtn Cmax est optimale. Il a montré aussi que la règle SPT donne une solution
, | |

optimale pour le problème 1, h1 pmtn C Le problème de minimisation de la plus grande valeur


| | i.

de latence (lateness) 1 h1 pmtn Lmax peut être optimalement résolu avec la règle EDD. Finale-
, | |

ment, il a montré que la minimisation du nombre des tâches en retard 1, h1 pmtn U peut aussi | | i

être résolu de manière optimale à l’aide de l’algorithme de Moore-Hodgson [114].


Il est connu que le problème 1 w C peut être optimalement résolu par la règle W SPT
|| i i

(Weighet Shortest Processing Time). Lee montre que le problème devient N − si la P Dif f icile

contrainte d’indisponibilité est prise en compte (1 1 C ) en le transformant en un problème


, h || wi i

de partition qui est NP −Difficile [57]. Lee a proposé une programmation dynamique et plusieurs
heuristiques pour résoudre ce problème. Dans le cas où la préemption des tâches est interdite,
l’auteur a montré que le problème 1 ,h1 pmtn Cmax est NP Difficile au sens faible et que la
| | −

règle LPT mène à une erreur relative inférieure ou égale à 13 . De plus, il a montré que 1 1 max, , h ||L

1 1
, h || Ui et 1 1 w sont
, h || −
i Ci au sens faible et que la règle
NP Dif f iciles garantit E DD

une erreur inférieure ou égale à max ( max est la plus grande durée opératoire). Il a également
p p

prouvé que la règle de Moore-Hodgson mène à une erreur relative inférieure ou égale à 1 pour le
deuxième problème (1 1 U ) et que le ratio de performance de l’heuristique SW PT peut être
, h || i

arbitrairement grand pour le problème 1 h1 w C alors que pour le problème 1 h1 C a une


, || i i , || i

erreur de 27 pour la règle S . L’auteur a étudié le cas de machines paralèlles (2 machines et plus)
PT

et le cas de flowshop.
Dans [132] Sadfi a étudié le même problème que Lee et Liman. Il a développé un algorithme
de programmation dynamique et une heuristique ayant une garantie de performance égale à 20 17 .

Récemment, Kacem et Chu ont étudié le problème 1 1 w et ont proposé deux heuristiques , h || i Ci

99
basées sur la règle . Sous certaines conditions spécifiques, le rapport de la performance
W SP T

garantie au pire cas de ces deux heuristiques est 3. Cette borne est atteinte. Si de telles conditions
ne sont pas réunies, le rapport de la performance est infini. Ces résultats sont aussi valables dans
le cas asymptotique [84].
Dans [99] Lee a étudié les problèmes d’ordonnancement sur une seule machine et sur machines
parallèles. La préemption des tâches est permise. Il a étudié le problème 1 1 pmtn C qui ,h | | i

peut être résolu avec la règle SPT . Il a étudié aussi le problème 1 h1 pmtn w C qui est N −
, | | i i P

Dif f icile au sens ordinaire, même dans le cas où les poids des tâches sont égaux à leurs temps
de traitement ( = ). L’auteur a proposé une programmation dynamique qui peut résoudre
wi pi

le problème en ( O max ) avec le nombre des tâches,


n.R.p n la date de début de la période
R

d’indisponibilité et max la plus grande durée opératoire des tâches.


p

Graves et Lee [68] ont étudié les problèmes de minimisation de la somme pondérée des dates
de fin d’exécution et du retard maximal ( max) sous différentes contraintes. Les périodes d’in-
L

disponibilité sont à durées fixes, égales à . La préemption des tâches est interdite pour le
T

problème 1 1 w C et semi-préemptive pour les problèmes 1 h1 s pmtn w C 1 h1 s


, h || i i , | − | i i, , | −

pmtn , 2T w C et 1, h1 s pmtn, 2T Lmax. Ils ont montré que lorsque l’horizon est grand par
| i i | − |

rapport à T , ces problèmes sont NP Difficiles. En revanche, lorsque l’horizon est petit par rap-

port à T , ils ont montré que le problème de minimisation de la somme des dates de fin d’exécution
est polynomial. La règle S PT garantit l’optimalité de ce problème. La règle EDD est optimale
pour le problème de minimisation de Lmax.
Wang et al. [159] ont étudié le problème 1, hk pmtn w C Ils ont montré que ce problème est
| | i i.

NP − Difficile. Ils ont considéré deux configurations distinctes. Dans la première configuration,
les poids w sont proportionnels aux temps de traitement p . Dans la deuxième configuration,
i i

les poids des tâches sont quelconques. Pour le premier cas, ils ont montré que la règle LPT
(en autorisant la préemption) est équivalente à la règle W SPT. Appliquée au problème sans
considération de préemption de tâches, cette règle donne une garantie de performance, au pire cas,
inférieure ou égale à 2 Pour la deuxième configuration, ils ont proposé une nouvelle heuristique
.

pour laquelle la performance garantie au pire cas est inférieure ou égale à 2.

100
4.2.2 Cas d’ateliers

D’autres travaux ont été réalisés et concernent les problèmes d’ordonnancement d’atelier (ma-
chines parallèles, flowshop et openshop) avec des contraintes d’indisponibilité pour minimiser de
différents critères. Ces travaux sont récapitulés dans les tableaux 4.1, 4.2, 4.3 et 4.4 qui suivent :

T . 4.1: Cas de deux machines parallèles

Problème(s) [référence] Résultats


P 2 11,h C [102]
|| i
- Problème NP-Difficile
- L’une des deux machines n’est pas disponible - Programmation dynamique
à partir d’un instant . t

- Deux heuristiques : asymptotiquement


P 2 11,h ||[115] Ci optimales
- Les machines ne sont disponibles - Une borne inférieure
que sur des intervalles précis et - La règle SPT est asymptotiquement
indépendants. optimale quand le nombre des tâches
tend vers l’infini.
1) P2, h21 pmtn w C [100]
| | i i
- Programmation dynamique (1) et (2)
2) P2, h21 Cmax ||

- Programmation dynamique
- Heuristique M SP T 2
C [133] - l’erreur moyenne entreM SP T 2 et la
P 2, hj 1 || i
solution optimale est de 1 8%
,

- Amélioration de la règle
SP T de plus
de 80% et parfois 100%
P 2 pmtn|Cmax
, h11 |
[107] - Complexité d’algorithme de résolution
P 2, h11||Cmax exponentielle

Dans la suite, nous considérons le problème d’ordonnancement sur une machine avec une
seule indisponibilité. L’objectif est de minimiser la somme pondérée des dates de fin d’execution
(1, hk w C ). La période d’indisponibilité est connue à l’avance.
|| i i

101
4.3 Etude du problème 1 , h1 || wi Ci

4.3.1 Problématique
Soit le problème défini comme suit : ordonnancer tâches sur une machine. Pour chaque
P N

tâche , ∈ = {1 2
i i J , ,...,N}, on connaît la durée opératoire (processing time ) et le poids w
pi i

(weight ). L’objectif est de minimiser la fonction = Favec la date de fin d’exécution de


i wi .Ci Ci

la tâche . La machine est indisponible entre la date 1 et la date T2. La préemption est interdite.
i T

4.3.2 Bornes inférieures et propriétés

Nous désignons Ppre le même problème en autorisant la préemption.


Si dans le problème P , toutes les tâches sont insérables avant T1, le problème peut être résolu
optimalement par la règle W SPT . En conséquence, nous considérons uniquement les problèmes
où toutes les tâches ne peuvent être insérées avant la date T1.
Dans la suite de cette partie, nous considérons que toutes les tâches sont triées dans l’ordre
W SPT , c’est-à-dire, wp11 ≤ wp22 ≤ ≤ wpNN On désigne par F ∗ (π) la somme pondérée minimale des
... .

dates de fin d’exécution des tâches pour le problème π et par Fσ (π) la somme pondérée des dates
de fin d’exécution des tâches de l’ordonnancement σ pour le problème π.

Borne inférieures de Wang et al .

Proposition 1 [ 159] : FW SRP T P


( pre ) − F ∗ (Ppre ) ≤ wg+1 · (T2 − T1) avec wg+1 le poids de la tâche
interrompue par la période d’indisponibilité. W SRP T est l’heuristique qui consiste à ordonnancer
les tâches en autorisant la préemption selon la règle d’ordonnancement de la plus petite durée
d’exécution pondérée restante (W eighted S hortest Remaining P rocessing T ime) : c’est-à-dire, le
même ordre que celui de la règle W SPT , mais en autorisant la préemption (voir figure 4-1).

Proposition 2 F ∗ (P ) ≥ FW SRP T (PPr e ) − wg +1 · (T2 − T1) = LB1 .

102
p g+1

p1 ... pg pg+2 ... n


p

0 C1 g
C T1 T2 Cg+2

F . 4-1: Illustration de la règle W SRP T

Borne inférieure basée sur la relaxation lagrangienne [84]

Définition 3 Soit wt un réel positif. Pwt est le problème avec les mêmes données que celui du pro-
blème P . De plus, nous associons un poids w pour la période de maintenance (considérée comme
t

une tâche de durée opératoire égale à δT = T2 − T1). Cette tâche doit être exécutée exactement à
la date T1, alors, nous avons la relation suivante (4.1) :

F ∗ (Pwt ) = F (P ) + wt · T2

(4.1)

Définition 4 RPwt est le problème relaxé de Pwt tel que la contrainte de débuter la tâche d’indis-
ponibilité à la date T1 est relâchée ; c’est-à-dire, celle-ci peut être exécutée à tout moment (avant
ou après T1). Il est évident que :

F ∗ RPw t
≤ F ∗ Pw t
(4.2)

Proposition 3 ∀wt ≥ 0, F ∗ (P ) ≥ FW SP T RPwt − w T2 = LB2 (w ) t · t .

Preuve. F ∗ (P ) = F ∗ Pw − w 2
Selon l’équation 4.1, on a
t t .T . D’après l’équation 4.2, on

F ∗ (P ) = F ∗ Pw − w · T2 ≥ F ∗ RPw − w T2
déduit que
t t RPw peut être optimalement
t t · . Or,
t

résolu par la règle W SP T . La proposition est donc justifiée.


Lemme 5 W SP T est optimale pour le problème P si δ = 0 avec δ = T1 − CgW SP T (voir figure

4-2).

Preuve. Considérons le cas où w = pδTg+1 wg+1 Dans ce cas, la solution optimale pour RPw
t · .
t

est réalisable pour le problème Pw . Elle est donc optimale pour Pw aussi.
t t

103
pg+1

δ δ

p1 ... p g g+2
p ... p n

0 C1 C g T1 T2 C g+2

p1 ... g
p g+1
p g+2
p ... n
p

0 C 1 C g T1 T2 g+2
C

F . 4-2: Illustration des règles WSPT et WSRPT

Etude de LB2 en fonction de w t Dans cette section, nous étudions la fonction LB2 en fonction

w
de la variation de t . Pour cela, nous allons considérer les w t appartenant aux intervalles du type :

δT
pk+1
· wk+1 ,
δT
pk
· wk avec k ∈ {1, 2, ..., N − 1}.

Pour wt ∈ wk +1 · pδTla tâche de maintenance sera ordonnancée entre la tâche k et


k+1
, wk ·
δT
pk
,

k + 1 (voir figure 4-3). La valeur de LB2 est donnée par la formule suivante :

LB2 (w ) = t i<k∪i>k+1 wi · Ci + wk · (Ck−1 + pk ) + wt · (Ck−1 + pk + δT )


(4.3)
+wk+1 · (Ck −1 + pk + pk+1 + δT ) − wt · T2

δT

p1 ... k-
p 1 p k p k+1 pk+2 ... n
p

0 C1 k-
C 1

F . 4-3: Ordonnancement de la tâche de maintenance entre la tâche k et k + 1

On peut donc conclure que :

104

∂LB2

 ≥ 0 Ck−1 + pk + δT ≥ T2
= Ck−1 + pk + δT − T2
si

∂w t

 ≤ 0 Ck−1 + pk + δT ≤ T2 si
(4.4)

La fonction LB2 est dérivable sur les intervalles wk+1 δTpk k Elle est croissante pour
δT
pk+1
· , ·w .

w si C ≥ T2 et décroissante pour w tel que C ≤ T2 (C = Ck−1 + pk + δT ).


t t t t . t

La fonction LB2 est continue par morceaux. En effet, il suffit de verifier la continuité aux points
wt = pδT wk+1· w = pδT
. De plus, pour wk+1 la tâche de maintenance peut être ordonnancée
· ,
k+1 k+1 t

juste avant ou juste après la tâche k + 1 car elle possède la même durée pondérée que la tâche
k + 1 (figure 4-4). La valeur de LB2 est donc donnée par l’équation suivante :

LB2 (w ) =
t i<k ∪i>k+1 wi · Ci + wk · (Ck−1 + pk ) + wk +1 · (Ck−1 + pk + pk+1 )
(4.5)
+p
δT
k+1
· wk+1 (Ck−1 + pk + pk+1 + δT ) − pδT
·
k+1
wk+1 T2 · ·

Nous pouvons ainsi vérifier que :


δT
lim +
LB2 (w ) = LB2 t
pk+1
· wk+1 (4.6)
wt −→ δT
pk +1 ·wk+1

δT

p1 ... p k-1 p k k+1


p k+2
p ... n
p

0 C1 Ck-1

F . 4-4: Illustration de calcul de LB2 pour w = wk+1 t ·


δT
pk+1

Cette fonction est croissante pour wt < pδTg+1 wg+1 (car dans ce cas, la période de maintenance
·

doit être ordonnancée après g + 1 et par la suite, elle se termine après T2). Elle est décroissante
pour w > pδT
t
g +1
wg+1 (car dans ce cas, la période de maintenance doit être ordonnancée avant
·

105
g + 1 et par la suite, elle se termine avant T2). Nous pouvons donc déduire que le maximum de la
fonction LB2 est atteint pour w = pδT+1 wg+1 D’ou lemme suivant :
t
g
· .

Lemme 6 La fonction LB2 admet un maximum global atteint pour w = pδT+1 wg+1 t
g
· selon l’équation

suivante :

δT
LB = max

2w ≥0
(LB2 (w )) = LB2
t
t
pg+1
· wg+1 (4.7)

Nous notons également que :

wt −→+∞
lim LB2 (w ) = −∞
t (4.8)

et que :

lim LB2 (w ) = −T t

w −→+∞ w 1 (4.9)
t t

Remarque 7 LB2∗ peut être calculée en O (N ) lorsque les tâches sont triées dans l’odre croissant

pi
de
wi .

Comparaison de LB1 et LB2∗ Considérons la figure 4-5 qui illustre les deux bornes inférieures
LB1 et LB2∗. LB1 est calculée par la règle WSRPT selon la formule donnée par la proposition 3
et LB2∗ est calculée par l’ordonnancement des tâches dans l’ordre WSPT et par l’introduction de
la tâche de maintenance entre (g + 1) et (g + 2) avec w t = pδT
g +1
· wg+1 .

Selon la figure 4-5, nous obtenons les équations suivantes :

LB1 = WSRPT + wg+1 · (Cg + δT + pg+1) + N WSRPT − wg+1 · δT


i=1 wi · Ci
g
i=g+1 wi · Ci
LB2∗ = WSP T + wg+1 · (Cg + pg+1 ) + wt · (Cg + pg+1 + δT ) + N WSPT − wt · T2
i=1 wi · Ci
g
i=g+2 wi · Ci
On peut remarquer que CiW SP T = CiW SRP T pour tout i = g + 1. Nous concluons donc que :
LB2∗ − LB1 = w · (Cg + pg+1 + δT ) − wt · T2 = wt · (Cg + pg+1 + δT − T2) ≥ 0
t .

Lemme 8 LB2∗ domine LB1 et LB2∗ = LB1 + pδTg+1 wg+1 (pg+1 + δ). · ·

Illustration de LB2∗

Exemple 9 Nous allons illustrer le calcul de la fonction LB2 par l’exemple donné dans la table
4.5. Pour cet exemple, on a : T1 = 6 et T2 = 9. On verifie que wp ≤ wp ≤ wp ≤ wp ≤ wp Pour 1
1
2
2
3
3
4
4
5
5
.

106
pg+ 1

Calcul de LB1 par WSRPT

δT

p1 ... p g p g+
2 ... p n

0 C1 C g T1 T2 C g+
2

Calcul de LB2
δT

1
p ... g
p pg+1 g+
p 2 ... n
p

0 C1 Cg T1 T2 C g+
2

F . 4-5: Comparaison de LB1 et LB2∗


déterminer la courbe de fonction de LB2, et d’après l’étude déja faite, nous avons besoin juste de
leurs valeurs aux points w = δTpk · wk pour k ∈ {1, 2, .., 5}, de sa valeur pour wt = 0 et de son
t

comportement asymptotique au voisinage de +∞.


Pour wt = 0, la tâche de maintenance occupe la dernière position comme l’illustre la figure 4-6.
Donc : LB2 (0) = (4 × 1) + (6 × 5) + (2 × 7) + (2 × 10) + (1 × 12) = 80.

δT

p1 p2 p3 p4 p5

0 1 5 7 10 12 15

F . 4-6: Calcul de LB2 pour w = 0 t

Pour w = δTp5 · w5 = 32 · 1 = 32 , la tâche de maintenance occupe la cinquième position comme


t

l’illustre la figure 4-7. Donc : LB2 32 = (4 × 1) + (6 × 5) + (2 × 7) + (2 × 10) + 32 × 13 +

(1 × 15) − 2 × 9 = 89.
3

Pour w = δTp4 · w4 = 33 · 2 = 2, la tâche de maintenance occupe la quatrième position comme


t

l’illustre la figure 4-8. Donc : LB2 (2) = (4 × 1) +(6 × 5) +(2 × 7)+ (2 × 10)+(2 × 13)+(1 × 15) −
(2 × 9) = 91.

107
δT

p1 p2 p3 p4 p5

0 1 5 7 10 13 15

F . 4-7: Calcul de LB2 pour w = 32 t

δT

p1 p2 p3 p4 p5

0 1 5 7 10 13 15

F . 4-8: Calcul de LB2 pour w = 2 t

Pour w = δT · w3 =
2 · 2 = 3, la tâche de maintenance occupe la troisième position comme
3
t p3

l’illustre la figure 4-9. Donc : LB2 (3) = (4 × 1) +(6 × 5) +(3 × 8)+ (2 × 10)+(2 × 13)+(1 × 15) −
(3 × 9) = 92.

δT

p1 p2 p3 p4 p5

0 1 5 8 10 13 15

F . 4-9: Calcul de LB2 pour w = 3 t

Pour w = δT · w2 =
4 · 6 = 2 , la tâche de maintenance occupe la seconde position comme
3 9
t p2

l’illustre la figure 4-10. Donc : LB2 92 = (4 × 1) + 92 × 4 + (6 × 8) + (2 × 10) + (2 × 13) +

(1 × 15) − 92 × 9 = 90, 5.

Pour w = δTp1 · w1 = 31 · 4 = 12, la tâche de maintenance occupe la première position comme


t

l’illustre la figure 4-11. Donc : LB2 (12) = (12 × 3) + (4 × 4) + (6 × 8) + (2 × 10) + (2 × 13) +


(1 × 15) − (12 × 9) = 47.

108
δT

p1 p2 p3 p4 p5

0 1 4 8 10 13 15

F . 4-10: Calcul de LB2 pour w = 92 t

δT

p1 p2 p3 p4 p5

0 3 4 8 10 13 15

F . 4-11: Calcul de LB2 pour w = 12 t

Pour w > δTp1 · w1 = 12, la tâche de maintenance occupe la première position comme l’illustre la
t

figure 4-11. Donc : LB2 (w ) = (w × 3) + (4 × 4) + (6 × 8) + (2 × 10) + (2 × 13) + (1 × 15) −


t t

(w × 9) = −6 · w + 125. On vérifie donc que : + ∞ −T1 = −6 . En particulier, pour


LB2 (w ) t
t t w t

w = 20 et w = 30, on obtient LB2 (20) = 5 et LB2 (30) = −55.


t t

En résumé, nous présentons le tableau des valeurs 4.5 et la courbe correspondente dans la figure
4-12.

100
80
60
40
LB2(wt)

20
0
-20 0 5 10 15 20 25 30 35

-40
-60
-80
wt

F . 4-12: La variation de LB2 en fonction de wt

Comme comparaison, le calcul de LB1 pour cet exemple est 89 (voir figure 4-13 et la formule de
109
LB1 dans la proposition 2) : LB1 = (4 × 1)+(6 × 5) +(2 × 10)+(2 × 13)+(1 × 15) − (2 × 3) = 89.
δT

p1 p2 p4 p5

0 1 5 6 9 10 13 15

p3

F . 4-13: Illustration de calcul de LB1


Donc, nous pouvons vérifier pour cet exemple que la valeur de LB2∗ est supérieure à LB1. Nous
pouvons également verifier que la maximum de LB2 est obtenu pour w = δTp3 · w3. t

4.3.3 Bornes inférieures basées sur le splitting [86]

Le principe de cette borne est basé sur l’approche de Potts et al. basée sur le découpage des
tâches en morceaux. Chaque tâche i peut être découpée en morceaux. Chaque morceau ( ) ni i, k

est caractérisé par une durée et un poids (1 ≤ ≤ et 1 ≤ ≤ ) tel que = n=1 p et


pi
k
wi
k
i N k ni pi k
i k
i

w = n=1 w
i k
i k
i .

Le problème (P ) se ramène donc à ordonnancer les tâches ( ) de telle manière que pour i, k

chaque tâche , les morceaux ( ) doivent être collés. Ce nouveau problème est noté ( ).
i i, k P

Considérons la quantité dans la solution optimale :


wi Ci

ni
wi Ci = wk i
· (ti + p)
i
k =1

t i
i est la date de début de la tâche .

→wC i i = wk t + n=1 p =  =1 w C + k=1−1 wik
ni
k=1 i · i k
i k
i
ni
k
k
i
k
i
ni ni h
h=k +1 pi
avec Cik la date de fin de ( ). i, k

Il s’ensuit que la valeur optimale ∗ peut s’écrire : F

110
 n 
N N n N n −1 
wC = wik Cik + wik  phi 
i i i

F

= i i (4.10)
i=1 i=1 k=1 i=1 k=1 h=k+1

La quantité Ni=1 nk=1 wik Cik représente la somme des dates de fin pondérées des morceaux.

i

Ainsi, F ∗ (P ) = F ∗ (P´) + Ni=1 nk=1−1 wik nh=k+1 phi i i


.

La relaxation de la contrainte, imposant que les morceaux soient collés, permet d’avoir une
borne inférieure. Pour cette relaxation RP´ de P´, on a :
 n 
N ni −1 
F (P ) ≥ F (RP´) + w  
i
∗ ∗ k
i phi (4.11)
=1 k =1
i h=k+1

Maintenant nous allons démontrer comment construire une borne inférieure en se basant sur
ce résultat.

Borne inférieure LB3

Considérons le découpage suivant :


∀ = + 1
i g = 1 (ces tâches ne sont pas morcelées).
, ni

Pour i = g + 1, n = 2 et on a :
i

◦ p1g+1 = δ, p2g+1 = pg+1 − δ


◦ wg1+1 = wg+1 · p δ+1g

◦ wg2+1 = wg+1 1 − p δ+1


·
g

Ainsi le problème (RP´) associé à ce découpage peut être optimalement résolu par W SPT (cf
le lemme précédant).

p1 ... g
p p1g+1 pg2+1 pg+2 ... N
p

0 C1 Cg T1 T2

F . 4-14: Découpage appliqué pour la borne LB3

111
p1 ... pg δ pg+1- δ pg+2 ... LB3

0 C1 Cg T1 T2 Cg+2

LB2
p1 ... pg pg+1 pg+2 ...

0 C1 Cg Cg+2

F . 4-15: Comparaison de LB2∗ et LB3

Comparaison de LB2∗ et de LB3


On peut écrire :
LB3 = =g+1 wiCi (W SRP T ) + wg1+1 (Cg + δ) + wg2+1 (Cg + pg+1 + δT ) + wg1+1 (pg+1 − δ)
i · · ·

=g+1 wi Ci (WSRPT ) + wg+1 pg+1 (Cg + pg+1) + wg+1 1 − pg+1 (Cg + pg+1 + δT )
δ δ
= i · · · ·

i=g+1 wi Ci (W SRP T ) + wg+1 (Cg + pg+1 + δT ) − pg+1 wg+1 δT


δ
= · · ·

= =g+1 wiCi (WSRPT ) + wg+1 (Cg + pg+1 + δT ) − pδTg+1 wg+1 δ


i · · ·

avec C (W SRP T ) la date de fin d’exécution de la tâche i dans l’ordonnancement obtenu en


i

appliquant la règle W SRP T .


LB2∗ = =g+1 wi Ci (WSRPT )+ wg+1 (Cg + pg+1 )+ pg+1 wg+1 (Cg + pg+1 + δT ) − pg+1 wg+1 T2
δT δT
i · · · · ·

= =g+1 wiCi (WSRPT ) + wg+1 (Cg + pg+1) + pδTg+1 wg+1 (Cg + pg+1 + T2 − T1 − T2)
i · · ·

=g+1 wi Ci (WSRPT ) + wg+1 (Cg + pg+1 ) + pg+1 wg+1 (Cg − T1 + pg+1)


δT
= i · · ·

=g+1 wi Ci (WSRPT ) + wg+1 (Cg + pg+1 ) + pg+1 wg+1 (Cg − T1 ) + pg+1 wg+1 pg+1
δT δT
= i · · · · ·

= =g+1 wiCi (WSRPT ) + wg+1 (Cg + pg+1 + δT ) − pδTg+1 wg+1 δ = LB3


i · · ·

Nous concluons donc que pour toute instance on a : LB2∗ = LB3 .

Borne inférieure LB4


Cette borne est basée sur le découpage suivant :

∀i ≤ N , ni =et = ∀1 ≤ ≤
wi pi
k pi
wi
= =1 k ni , wi
k wi
wi

Dans ce cas, le problème relaxé ( ´) se ramène à un problème d’ordonnancement des ( w )


RP i i

tâches en minimisant la somme des dates de fin avec des poids identiques.

112
L’application de la règle permet donc d’obtenir une borne inférieure
S RP T LB4 pour le pro-
blème. On obtient l’ordre suivant :
1 2 w1 1 2 w2 1 2 wN
p1 , p1 , . . . , p1 , p2 , p2 , . . . , p2 , . . . , p N , pN , . . . , pN
car pki = wp i
i
et wp11 ≤ wp ≤
2
2
... ≤ wpNN .

On peut donc vérifier facilement que :


∀ = + 1 n=1 w C + k=1 −1 wk h = wiCi (W SRPT )
h=k +1 pi
i k k ni ni
i g , k i i i
·

Il s’ensuit que :

LB4 = =g+1 wiCi (W SRP T ) + Cg + wpgg+1+1 + Cg + 2 wpgg+1+1 + + Cg + h wpgg+1+1


i · ... ·

+ Cg + δT + (h + 1) wpgg+1+1 + Cg + δT + (h + 2) wpgg+1+1 + + Cg + δT + wg+1 pg+1


+
ni −1
 · · ... ·
wg+1
k=1 wgk+1 ni h
h=k+1 g+1 p
avec h = w
δ · p g+1 .
g +1
 wg+1 +1 wg+1 −1
= =g+1 wi Ci (WSRPT ) + wg+1 · Cg + 2 · pg+1 + δ T · (wg+1 − h) + wg+1
pg+1
·
i 2 wg+1

= i= g +1 wi Ci (WSRPT ) + wg +1 · (Cg + pg +1 + δT ) − h · δT

En comparant avec LB2∗ , on peut écrire :

LB2∗ = =g+1 wiCi (WSRPT )+wg+1 (Cg + pg+1)+ pδTg+1 wg+1 (Cg + pg+1 + δT )− pδTg+1 wg+1 T2
i · · · · ·

= =g+1 wiCi (W SRPT ) + wg+1 (Cg + pg+1 + δT ) + pδTg+1 wg+1 (Cg + δT − T2)
i · · ·

=g+1 wi Ci (W SRPT ) + wg+1 (Cg + pg+1 + δT ) − pg+1 wg+1 δ


δT
= i · · ·

LB4 − LB2∗ = −h δT + pδT


Il s’ensuit que :
g +1
wg+1 δ = δT pgδ+1 wg+1 − h · · · ·

or, h wpgg+1
+1 ≤ δ < (h + 1) wp +1+1 g
g
. On en déduit donc que : LB4 − LB2∗ ≥ 0 . En conclusion, nous

obtenons :

δ
LB4 = LB2∗ + δT · wg+1 − h (4.12)
pg+1
Remarque 10 LB4 peut être calculée en O (N ) lorsque les tâches sont triées dans l’odre croissant
pi
de wi .

4.3.4 Approches exactes pour le problème 1 , h1 || wi Ci

Dans cette sous-section, nous proposons trois approches exactes pour résoudre le problème.
La première approche est une branch and bound basée sur les différentes propriétés et résultats
présentés dans les paragraphes précédents. La deuxième approche est un programme linéaire en

113
nombres entiers. La troisième est une programmation dynamique. Dans la suite, nous présentons
une description pour chacune de ces méthodes.

Procédure de séparation et d’évaluation (PSE)

Basée sur la nouvelle borne inférieure LB4, nous allons proposer un algorithme de séparation et
d’évaluation (branch and bound algorithm) pour résoudre le problème. Les tâches sont triées selon
la règle WSPT . Il est évident que, dans la solution optimale, l’ensemble des tâches ordonnancées
avant le début de la tâche de maintenance (avant T1) sont ordonnées selon la règle WSPT . La
même propriété est aussi valable pour l’ensemble des tâches ordonnancées après la période de
maintenance (après T2). Pour cette raison, dans notre algorithme de séparation, le noeud est
caractérisé par les éléments suivants :
◦ le niveau k qui représente le nombre des tâches ordonnancées,
◦ l’affectation partielle des tâches ordonnancées : A = {x1 , x2 , ..., xk } avec x ∈ {0, 1} ∀i ≤ k
i

tel que : xi =1 si la tâche i est ordonnancée avant la date T1 et xi = 0 si la tâche i est

ordonnancée après la date T2 ,

◦ la borne inférieure basée sur les résultats dans la section précédente.

La borne supérieure est calculée à l’aide des heuristiques W S P T et M W SP T [83]. Dans l’étape

de séparation, nous avons deux possibilités : ordonnancer la tâche (k + 1) avant T1 (dans ce cas,
xk+1 = 1) ou après T2 (xk+1 = 0). Après le calcul de la borne inférieure, le noeud est supprimé
de la liste active si la valeur de la borne inférieure est supérieure ou égale à la borne supérieure
actuelle.

Modèle linéaire en nombres entiers


Dans ce paragraphe, on propose un modèle linéaire en nombres entiers afin de tester ses per-
formances sur le problème étudié. Un tel modèle peut être décrit comme suit :

Minimizer N=1 w .C i i i

Sous les contraintes :



C ≥ (1 − x ) · T2 +
i i
i
j =1 p
j − i
j =1 x ·p
j j ∀1 ≤ i ≤ N

114
C≥
i
i
j =1 xj · pj ∀1 ≤ i ≤ N
N xj · pj ≤
j =1
T1

xi ∈ {0 1}
, ∀1 ≤ ≤ i N

Notons que x = 1
i si la tâche i est ordonnancée avant T1 et que xi = 0 si la tâche i est

ordonnancée après T2 . On désigne par C i la date de fin d’exécution de la tâche i.

Programmation dynamique (DP)


blème est de trouver une partition de tâches en deux sous-ensembles Ω1 et Ω2 tels que les
Le pro

tâches du sous ensemble Ω1 sont ordonnancées avant la période de maintenance et les tâches de Ω2
sont ordonnancées après la période de maintenance. On définit x tel que x = 1 si la tâche ∈ Ω1 i i i

et = 0 sinon (Nons supposons que les tâches sont indexées suivant l’ordre non-décroissant de
xi

leurs durées opératoires pondérées). A cause de la dominance de la règle , les tâches de W SP T

chaque sous-ensemble doivent être ordonnancées dans l’ordre . W SP T

Soit ( ) la plus petite somme pondérée des dates de fin d’exécution des tâches de l’ensemble
f i, t

{1 2
, } où la somme des durées opératoires des tâches de Ω1 est . Si une telle solution
,...,i , t

n’existe pas, on impose que ( ) = +∞. La formulation dynamique du problème est basée sur
f i, t

la formulation simple suivante :


i

( ) = x min
f i, t σ (i − 1, t − x · p ) + x · w · t + (1 − x ) · w ·
i i i i i i T2 + pk − t
∈{0 1} i ,
k=1

f (0, 0) = 0 f (0, t) = +∞ ∀t ≤ T1 F ∗ = min0≤ ≤T1 ( )


avec , et t f N, t .

La complexité de cet algorithme est ( 1) Cette formulation répresente une extension de


O N .T .

celle proposée par Sadfi ( [132]) pour 1 h1 C , || i.

4.3.5 Résultats expérimentaux


Dans ce paragraphe, nous reportons quelques résultats expérimentaux qui ont été réalisés pour
évaluer les performances des méthodes proposées. Les tests expérimentaux ont été réalisés sur un
AMD Athlon sous Windows XP. Dans le suite, nous donnons la description des données tests, les
résultats obtenus et quelques analyses et conclusions concernant ces tests numériques.

115
Les données tests
Trois séries ont été aléatoirement générées telles que p ∈ [1 i , 100], wi ∈ [1, 15]. Les variables T1
et 2 ont été générées comme suit :
T

◦ 1ère série : 1 = 12 ·
T p et T2 = T1 + N1
i i p · i i.

◦ 2ème série : T1 = 1
4 · i pi et T2 = T1 + N1 · i pi .
◦ 3ème série : T1 = 3
4 · i pi et T2 = T1 + N1 · i pi .

Résultats
La méthode branch and bound et la programmation dynamique ont été implémentées en
langage C et testées sur les trois séries de problèmes. En outre, le modèle linéaire en nombres
entiers a été testé en utilisant le solveur CPLEX sur les mêmes séries de problèmes. Les différents
résultats sont reportés dans les tableaux 4.7 à 4.15. Pour chaque méthode, on donne le temps
de calcul nécessaire pour trouver la meilleure solution. La colonne ‘best of ” indique la meilleure
solution trouvée avant d’arrêter le programme. Dans le cas de la branch and bound ou de la
programmation en nombres entiers, nous indiquons aussi le nombre des noeuds nécessaire pour
converger. Le symbole “∗” indique que le programme a été interrompu avant de trouver la solution
optimale. Selon ces résultats, il est évident que la branch and bound est plus performante que la
programmation linéaire en nombres entiers. C’est aussi le cas pour la programmation dynamique.
Nous pouvons remarquer que le temps et le nombre des noeuds nécessaires avant d’arrêter le
programme pour la branch and bound (ou la programmation dynamique) sont toujours plus faibles
que pour la programmation dynamique. D’une part, la programmation en nombres entiers est
incapable de résoudre des problèmes de taille supérieure à 80 tâches. D’autre part, la branch
and bound permet de résoudre des problèmes d’une taille qui avoisine les 1000 tâches. Pour la
programmation dynamique, les résultats obtenus paraissent plus performants que les deux autres
méthodes. En effet, cette méthode peut résoudre des problèmes de plus que 3000 tâches (cas de
la deuxième série). Le temps de calcul nécessaire pour résoudre ces problèmes est toujours plus
court et l’exécution de l’algorithme ne conduit pas à des problèmes de mémoire.

4.3.6 Etude expérimentale de la borne LB4 et de la borne linéaire


116
Comparaison des temps de calcul pour PL, B&B et PD

Time (s)
1200,00

1000,00
800,00
PL
600,00 B&B
400,00 PD

200,00
0,00
0 10 20 30 40 50 60
-200,00
N

F . 4-16: Comparaison de différentes méthodes

Pour expliquer la différence entre les performances de deux méthodes, nous avons étudié la
performance de la borne LB4 et celle de la borne linéaire LBLP (la borne inférieure obtenue en
relaxant la contrainte d’intégrité dans le modèle linéaire). Ces bornes inférieures ont été calculées
sur les trois séries précédentes. Les différents résultats sont présentés dans le tableau 4.16. Nous
pouvons donc expliquer la performance de la branch and bound. En effet, la valeur de la borne
inférieure LB4 est toujours proche de la solution optimale pour toutes les instances testées. En
outre, la valeur de la borne linéaire est toujours plus petite que la valeur de LB4 ; ceci conduit à
un nombre de noeuds considérable et à un temps de calcul plus important. La figure 4-17 donne le
ratio (100% BorneInf /OP T ) obtenu pour chaque borne inférieure (LB4 et LBLP ). Elle montre
·

clairement que LB4 domine LBLP .

4.3.7 Comparaison de la branch and bound et de la programmation


dynamique
Selon les résultats des tableaux 4.10 à 4.15, nous pouvons conclure que la programmation
dynamique est plus performante que la branch and bound pour les différentes simulations et permet
de résoudre des problèmes de taille de 3000 tâches. En effet, la complexité de programmation
dynamique reste correcte dans ce cas. En revanche, à partir de 3000 tâches, la programmation
dynamique devient incapable de résoudre le problème à cause du terme T1 dans la formule de
la complexité qui devient très large. Ce terme devient de plus en plus grand lorsque 1≤ ≤N pi i

117
100

ratio de la
) 80
borne LB4
%
(
e
n
r ratio de la
o 60
b borne linéaire
a
l
e
d 40
o
i
t
a
r
20

0
N
0 100 200 300 400 500 600 700 800 900

F . 4-17: Comparaison de LB4 et de LBLP

est grand. Pour une valeur plus grande de T1, la branch and bound peut être plus efficace pour
résoudre le problème ou pour donner une solution approchée. Notons que pour la deuxième série,
le term T1 n’est pas très grand (T1 = 14 1≤ ≤N pi) et que la programmation dynamique est très
· i

efficace pour résoudre le problème.


En se basant sur cette constatation, nous concluons qu’il n’est plus efficace d’utiliser la pro-
grammation dynamique dans le cas d’une valeur de T1 très large. Pour confirmer une telle conclu-
sion, nous avons construit une quatrième série d’instances générées comme suit :
◦ N ∈ {500 600 700 800 900 1000 1200}
, , , , , , ,

◦ pi ∈ [1, 250],
◦ wi ∈ [1, 50],
◦ T1 = 1
2 · i pi ,

◦ T2 = T1 + N1 · i pi .

Les différents résultats obtenus pour cette série sont reportés dans le tableau 4.17. Nous re-
marquons que la programmation dynamique est mois efficace que la branch and bound pour ces
instances. En effet, la temps de calcul nécessaire par la programmation dynamique est plus élevé.
Ceci confirme la conclusion précédente. La figure 4-18 illustre graphiquement ces résultats.

118
1000
900

800 Temps passé


par la B&B

temps de calcul (s)


700

600 Temps passé


500 par la PD
400

300
200
100
0 N
450 550 650 750 850 950 1050 1150 1250

F . 4-18: Temps de calcul pour la branch and bound et pour la programmation dynamique : 4ème
série
4.4 Conclusion

Après un survol bibliographique, nous avons considéré un problème d’ordonnancement sur


une seule machine avec une seule contrainte d’indisponibilité. Nous avons étudié le critère de la
somme pondérée des temps de fin d’exécution. Plusieurs bornes inférieures et quelques propriétés
mathématiques du problème ont été étudiées. Nous avons aussi proposé une branch and bound
basée sur ces résultats. Cette méthode a été comparée avec une programmation linéaire en nombres
entiers et une programmation dynamique. Les différents résultats nous permettent de conclure que
la borne inférieure LB4 domine la borne linéaire et permet de construire une branch and bound
compétitive. En outre, nous proposons un algorithme de programmation dynamique avec une
complexité pseudo-polynomiale. Les différentes méthodes ont été testées et évaluées. La chapitre
suivant présente sur un autre exemple de problème comment de telles méthodes peuvent être
appliquées.

119
T . 4.2: Cas de m machines paralèlles (m > 2)

Problème(s) [référence] Résultats


Pm, hjk pmtn X [134] - X : construire un ordonnancement faisable
| |
- O(n + mlogm)
Pm, hjk pmtn, ri, di X [135] - (même problème que Schmidt généralisé)
| |
- O(nmlogm)
- Borne inférieure
Pm, hr k Cmax [96]
|| - Analyse de performance de la règle
LPT (ε = 32 − 21m )
j
- La période d’indisponibilité de
la machine j est [0, r ] j - Analyse de performance de la règle
MLPT (ε = 43 )
- Analyse de performance de la règle
1) Pm , hj1 pmtn Cmax [100]
| | LPT (1)
2) Pm , hj1 Cmax || - Analyse de performance de la règle
LS (List Scheduling) et de la règle LPT (2)
Pm, hj1 Cmax [78] - Analyse au pire cas : si le nombre
||

- Chaque machine peut/(ne peut pas) des machines ayant une indisponibilité
avoir une periode d’indisponibilité est inférieur à la moitié de m, alors
l’erreur de la règle LPT = 2
- MULTIF IT : heuristique utilisée dans
le bin-packing
Pm, hr k Cmax [28]
j
||
- La meilleure borne au pire cas trouvée
9
7 + 2−k
- Borne inférieure (modifiée en fonction
Pm , hrj k ||Cmax [101] de m le nombre des machines actives)
- Même problème que Lee [96] - Analyse de performance de la règle
- Quelques machines peuvent être LPT (ε = 32 − 2m1 )
inactives dans la solution optimale. - Analyse de performance de la règle
M LP T (ε = 43 )

T . 4.3: Cas d’open-shop

Problème(s) [référence] Résultats


- Le problème est N P − Dif f icile
O 2, h11 Cmax [25]
|| - Algorithme approché
- Analyse de performance au pire cas ε = 43

120
T . 4.4: Cas de flow-shop

Problème(s) [référence] Résultats


- Tous les problèmes sont
NP − Difficiles
1) 2 j1 pmtn Cmax - Programmation dynamique
F ,h |

2) F 2, h11 pmtn Cmax [97]


|
pseudo-polynomiale
|

3) F 2, h21 pmtn Cmax


|
- Analyse de performance de
| |
deux heuristiques
en O(n log n) pour (2) : ε = 12
et pour (3) : ε = 13
1) F 2, hj1 Cmax
|| - Tous les problèmes sont
2) F 2, h11 pmtn Cmax
| [98] | N P − Difficiles sauf si les deux machines
3) F 2, h21 s pmtn Cmax
| − | possèdent la même période d’indisponibilité
Chaque machine peut/(ne peut) - Programmation dynamique
avoir de période d’indisponibilité - Analyse de performance des heuristiques
- Montre que l’erreur de l’heuristique de
F 2, h11 pmtn Cmax[30]
| | Lee [97] ε = 12 est atteinte
(même problème que Lee [97]) - Amélioration de l’heuristique
- Analyse de performance au pire cas ≤ 13
2) 2 11
F ,h max [158]
|nwt|C - Amélioration de deux heuristiques
3) F 2, h21 nwt Cmax
| | - Analyse de performance au pire cas ≤ 53
- Heuristiques constructives, recherche locale,
F 2, hjk |pmtn|Cmax [22] recuit simulé
- La solution optimle est obtenue pour
plusieurs instances
Fm, hjk ||Cmax[4] - Le problème est N P − Difficiles
Période d’indisponibilité à performer au sens fort
dans une fenêtre de temps - Algorithme génétique et recherche tabou
F 2, h21 pmtn Cmax[24]
| | - Amélioration de l’heuristique
(même problème que Lee [97]) - Analyse de performance au pire cas ≤ 54

T . 4.5: Tableau des données


Tâche i 1 2 3 4 5
p i 1 4 2 3 2
w i 4 6 2 2 1

121
T . 4.6: Table des valeurs de la fonction LB2
wt LB2(wt)
0 80

1,5 89

2 91

3 92

4,5 90,5

12 47

20 5

30 -55

T . 4.7: Résultats obtenus pour la programmation linéaire : Série 1


N Bestof Time Nodes
5 3841 0,01 26
10 17644 0,04 13
15 35597 0,07 60
20 64066 0,33 343
25 96615 1,72 1639
30 144238 7,33 6939
35 162082 25,8 17588
40 209672 97,7 65798
45 270505 452,46 303680
50 334288 2977,26 1387383
60 460778* 1927 816171
80 787270* 11171,36 2989682

122
T . 4.8: Résultats obtenus pour la programmation linéaire : Série 2
N Bestof Time Nodes
5 4177 0,01 0
10 18473 0,03 8
15 37914 0,08 50
20 65970 0,16 132
25 99710 0,6 686
30 147379 1,82 1863
35 165473 3,24 2885
40 212766 12,16 9587
45 274927 54,2 39428
50 339344 134,59 81532
60 465342 826,47 375481
80 794254* 7655,16 2431887

T . 4.9: Résultats obtenus pour la programmation linéaire : Série 3


N Bestof Time Nodes
5 3351 0,01 0
10 16601 0,04 22
15 35115 0,09 72
20 62622 0,31 322
25 94486 0,89 970
30 141833 3,41 2976
35 166016 6,58 5334
40 206330 21,8 16074
45 267351 90,31 57374
50 330862 661,12 366441
60 456003 14928 6972634
80 783474* 11053,51 3454997

123
T . 4.10: Résultats obtenus pour la branch and bound : Série 1
N Bestof Time Nodes
5 3841 0 6
10 17644 0 22
15 35597 0 16
20 64066 0 25
25 96615 0 65
30 144238 0 97
35 162082 0 63
40 209672 0 279
45 270505 0 251
50 334288 0 283
60 459607 0 179
80 786214 0,01 591
100 1197001 0,03 1034
150 2533074 0,05 1641
200 4288875 0,08 1835
250 6272140 0,32 6215
300 9014746 0,27 4383
350 12354413 0,14 2086
400 16149606 0,37 4352
450 20093503 24,29 30010
500 24513907 0,64 6339
550 29730531 4,51 17393
600 36168484* 292,49 54950
650 43443480* 231,923 50726
700 51053065* 214,87 47860
750 58998439* 262,938 43715
800 66838958* 240,776 40966
850 75309474 9,32 10287
900 82991955* 467,752 36866
950 91283109 26,89 19828
1000 101620801* 327,861 33134

124
T . 4.11: Résultats obtenus pour la branch and bound : Série 2
N Bestof Time Nodes
5 4177 0 10
10 18473 0 17
15 37914 0 66
20 65970 0 78
25 99710 0 230
30 147379 0 37
35 165473 0 122
40 212766 0 89
45 274927 0,01 431
50 339344 0,01 311
60 465342 0 89
80 793384 0,01 529
100 1205941 0,01 456
150 2546186 0,02 818
200 4306042 0,17 3941
250 6292505 0,04 871
300 9039334 0,18 2838
350 12383316 0,05 813
400 16183102 1,97 23555
450 20130749 60,45 52545
500 24554984 59,58 48044
550 29776004 0,74 6819
600 36218545 0,73 6194
650 43498188 10,86 22505
700 51113422 121,1 38117
750 59062841 1,02 7026
800 6690819 0,32 2192
850 75382531 0,26 1746
900 83058702 0,26 1588
950 91364090 1,71 9561
1000 101705362* 287,583 33116

125
T . 4.12: Résultats obtenus pour la branch and bound : Série 3
N Bestof Time Nodes
5 3351 0 5
10 16601 0 13
15 35115 0 20
20 62622 0 35
25 94486 0 37
30 141833 0 43
35 166016 0 66
40 206330 0 40
45 267351 0 86
50 330862 0 79
60 456003 0,01 652
80 780699 0,02 809
100 1190758 0,02 842
150 2524283 0,05 1394
200 4277766 0,03 894
250 6258978 0,41 7774
300 8998975 0,05 916
350 12335896 0,04 641
400 16128628 0,78 9441
450 20069866 0,42 4719
500 24488413 1,89 18572
550 29702046 0,38 3673
600 36136698 1,79 14776
650 43407996 0,79 6081
700 51014387* 198,535 47694
750 58956919* 1377,24 44471
800 66795264* 248,557 41691
850 75262990* 197,754 39293
900 82943207* 197,253 37216
950 91233621* 219,225 35080
1000 101565993* 188,16 33631

126
T . 4.13: Résultats obtenus pour la programmation dynamique : Série 1
N Bestof Time
5 3841 0
10 17644 0
15 35597 0
20 64066 0,01
25 96615 0,01
30 144238 0,02
35 162082 0,02
40 209672 0,02
45 270505 0,03
50 334288 0,04
60 459607 0,06
80 786214 0,17
100 1197001 0,30
150 2533074 0,76
200 4288875 1,54
250 6272140 2,69
300 9014746 4,43
350 12354413 6,70
400 16149606 9,71
450 20093503 13,55
500 24513907 18,29
550 29730531 24,10
600 36168480 31,41
650 43443438 41,06
700 51053065 50,44
750 58998430 63,61
800 66838957 76,47
850 75309474 88,32
900 82991955 106,28
950 91283109 119,90
1000 101619985 142,46
1100 123113699 193,59
1200 145949346 261,57
1400 198624074 406,22
1500 228545688 564,51
2000 407598503 1280,68
2500 632308500 2741.47

127
T . 4.14: Résultats obtenus pour la programmation dynamique : Série 2
N Bestof Time
5 4177 0
10 18473 0
15 37914 0
20 65970 0,01
25 99710 0
30 147379 0,01
35 165473 0
40 212766 0,01
45 274927 0,02
50 339344 0,02
60 465342 0,03
80 793384 0,10
100 1205941 0,17
150 2546186 0,42
200 4306042 0,80
250 6292505 1,4
300 9039334 2,26
350 12383316 3,47
400 16183102 5,01
450 20130749 6,97
500 24554984 9,35
550 29776004 12,36
600 36218545 16,06
650 43498188 21,02
700 51113422 26,02
750 59062841 32,44
800 6690819 39,06
850 75382531 44,68
900 83058702 54,17
950 91364090 61,28
1000 101705085 72,80
1200 146061852 131,18
1400 198743126 204,07
1500 228675168 282,83
2000 407772898 659,10
2500 632524601 1403.62
3000 894959660 2338.8

128
T . 4.15: Résultats obtenus pour la programmation dynamique : Série 3
N Bestof Time
5 3351 0
10 16601 0
15 35115 0.01
20 62622 0.01
25 94486 0.01
30 141833 0.01
35 166016 0.02
40 206330 0.03
45 267351 0.04
50 330862 0.06
60 456003 0.09
80 780699 0.25
100 1190758 0.45
150 2524283 1.09
200 4277766 2.27
250 6258978 4.00
300 8998975 6.62
350 12335896 10.12
400 16128628 14.50
450 20069866 20.38
500 24488413 27.47
550 29702046 36.05
600 36136698 47.04
650 43407996 61.66
700 51014341 75.68
750 58956861 95.44
800 66795002 115.14
850 75262943 132.75
900 82943203 159.35
950 91232667 180.16
1000 101565993 214.16
1100 123053874 286.11
1200 145883922 384.07
1300 172869143 494.35
1400 198549529 609.20
1500 228463861 838.50
2000 407489833 2398.49

129
T . 4.16: Comparaison des deux bornes inférieures
n LB4 LBLP Bestof Ratio LB4 Ratio LBLP
5 3109 2305 3790 82.04 60.82
10 17046 12072 17573 97.00 68.70
15 35570 14778 36209 98.24 68.43
20 63767 44140 64219 99.30 68.73
25 96281 66593 96937 99.32 68.70
30 144211 99594 144483 99.81 68.93
35 162110 112094 164524 98.53 68.13
40 209285 144559 209589 99.85 68.97
45 270419 186519 270928 99.81 68.84
50 334670 230246 334831 99.95 68.76
60 460016 316275 460317 99.93 68.71
80 786536 541400 786855 99.96 68.81
100 1197629 824897 1197900 99.98 68.86
150 2534244 1743298 2534514 99.99 68.78
200 4290689 2949166 4290894 100.00 68.73
250 6274384 4313966 6274541 100.00 68.75
300 9017557 6200505 9017648 100.00 68.76
350 12357828 8503942 12357875 100.00 68.81
400 16153624 1114307 16153779 100.00 68.80
450 20097844 14736420 20098039 100.00 73.32
500 24518929 15965743 24519101 100.00 65.12
550 29736112 20458165 29736194 100.00 68.80
600 36174410 24881107 36174576 100.00 68.78
650 43449724 29882155 43449888 100.00 68.77
700 51060074 35116882 51060291 100.00 68.78
750 59005825 40574432 59006066 100.00 68.76
800 66847176 45971541 66847414 100.00 68.77
850 75318234 51798269 75318332 100.00 68.77
900 83001170 57089725 83001288 100.00 68.78
950 91293104 62791292 91293607 100.00 68.78
1000 101630134 69896254 101630719 100.00 68.77

130
T . 4.17: Comparaison de la branch and bound avec la programmation dynamique sur la qua-
trième série
N OPT TempsB&B TempsPD
500 199075673 0.79 56.61
600 293949624 17.68 96.81
700 414698746 52.24 176.33
800 542934053 33 232.69
900 673722106 44.6 322.31
1000 823782052 6.47 449.31
1200 1185505044 35.76 821.05

131
Chapitre 5

Etude du problème 1, h1|ri|Cmax

Dans ce chapitre, nous étudions un autre problème avec une indisponibilité indépendante. L’ob-
jectif est de minimiser le makespan. L’indisponibilité est connue à l’avance. Les tâches ont des
dates d’arrivée. La préemption est interdite. Nous proposons trois approches exactes : une pro-
grammation linéaire en nombres entiers, une méthode de branch and bound et une programmation
dynamique. Des tests numériques sont présentés et des résultats sont discutés.1

5.1 Formulation du problème


Le problème abordé consiste à ordonnancer N tâches sur une machine, chaque tâche i à une
date de début au plus tôt r et une durée opératoire p . La machine est indisponible entre la date
i i

T1 et la date T2 à cause d’une tâche de maintenance préventive. Les valeurs T1 et T2 sont bien
connues à l’avance. La machine est de capacité unitaire : elle ne peut exécuter qu’une seule tâche
à la fois. La préemption des tâches est interdite. L’objectif est de minimiser les makespan (Cmax).
1
Ce travail a fait l’objet de la soumission [149].

132
5.2 Propriétés et analyse préliminaire
Définition 11 F IFO 2 désigne la règle de priorité qui consiste à ordonnancer les tâches selon

l’ordre croissant de leurs r.


i

Proposition 4 Cmax (FIFO) ≤ T1 alors FIFO est optimale (Cmax (F IFO) est le makespan
Si

de l’ordonnancement FIFO).
Définition 12 Un sous ensemble B de tâches constitue un bloc si dans l’ordonnancement FIFO,
les tâches de B sont ordonnacées d’une manière contiguë.
Exemple 13 Considérons l’exemple décrit dans le tableau 5.1 tel que T1 = 9 et T2 = 12.

T . 5.1: Tableau des données


Tâche i 1 2 3 4 5 6 7

pi 2 2 2 3 1 2 2

ri 0 1 5 6 7 17 18

bloc

1 2 3 4 5 6 7

0 2 4 5 7 9 12 15 16 17 19 21

F . 5-1: Illustration de la notion du bloc

Propriété : Si ri +pi > T1 et ri < T1 alors on peut augmenter la valeur de ri à T2 sans changer
la valeur de Cmax
∗ (Cmax
∗ est le makespan optimal).
Proposition 5 Si T2 ≤ ri ≤ rj alors i précède j dans la solution optimale.
2
First In First Out

133
Preuve. Les tâches dont les dates de début au plutôt sont supérieures à T2 ne sont pas direc-
tement soumises à la contrainte d’indisponibilité. En conséquence, la règle FIFO est dominante
pour le séquencement de ces tâches.
Proposition 6 Si B est un bloc qui se termine avant la date T1 dans l’ordonnancement FIFO,
alors ce même bloc peut être ordonnancé dans la solution optimale de la même manière.
Preuve. Par argument d’échange.
Proposition 7 FIFO est une règle dominante pour les deux sous ensembles des tâches avant et
après la période d’indisponibilité de la machine dans l’ordonnancement optimal.
Une conséquence importante des propositions précédentes consiste dans le fait que la résolution
de notre problème s’est réduit en réalité à la détermination d’un ordonnancement pour les tâches
qui ne vérifient pas la proposition 5 ni la proposition 6. L’ensemble de ces tâches sera noté . Ces
H

tâches peuvent être caractérisées comme suit :


◦ ∀i ∈ + p ≤ T1 : (c’est à dire, i peut être ordonnancé avant la période d’indisponibilité.
H, ri i

Cela garantit que i ne vérifie par la proposition 5).


◦ Si l’ensemble des tâches vérifiant la proposition 6 n’est pas vide, c’est à dire, il existe au
moins un bloc tel que les tâches de dans l’ordonnancement se terminent avant 1
B B
 F IF O T

alors min ∈H ri > maxl minj∈B rj + j ∈B pj Cela signifie que les tâches de H ne peuvent
i l l
.

commencer qu’après la fin de toutes les tâches des blocs précédents.


◦ Les tâches de H ne peuvent être toutes ordonnancées avant la période de maintenance :
min ∈H ri + ∈H pi > T1
i i .

◦ Les tâche de H forment un bloc dans l’ordonnancement FIFO sans contrainte d’indisponi-
bilité. En effet, si les tâches de H sont ordonnées selon les r croissants, cela se traduit par
i

des relations du type suivant : r +1 < C (FIFO) ∀i ∈ H avec C (FIFO) la date de fin des
i i i

la tâche i selon l’ordonnancement FIFO.


Proposition 8 Si le bloc H n’existe pas alors F IFO est optimale.
Preuve. Si le bloc H n’existe pas, cela signifie que les tâches doivent vérifier la proposition 5
ou la proposition 6. En conséquence, FIFO est optimale.
134
Dans le cas où toutes les tâches de H ont la même date de début au plus tôt (r = cte ∀i ∈ H ),
i

le problème est équivalent à un problème de sac à dos avec une capacité égale à (T1 − min ∈H ri) i

et des objets dont les volumes correspondent aux pi. Les utilités sont égales aussi aux pi. Dans un
tel cas, nous faisons référence aux travaux de Martello et al. sur le problème de ce type.
Proposition 9 Dans le cas d’un problème avec des durées opératoires unitaires, la règle F IF O
est optimale.
Preuve. Soit σ un ordonnancement optimal dans lequel il existe deux tâches i et j (avec
r < rj ) telles que j précède i. l’échange de i et de j ne déteriore pas le makespan. En conséquence,
i

il existe une solution optimale vérifiant le F IF O.


Dans la suite et sans perte de généralité, nous considérons uniquement les tâches appartenant
à l’ensemble H . On suppose donc que J = H et que min ∈J ri = 0. Le problème se ramène donc à
i

charger au maximum la machine entre 0 et T1.


Propriété 10 Soit Cmax
.
∗ le makespan de la solution optimale. Alors on a : Cmax
∗ ≥ min ∈J ri + i

i∈J pi + T2 − T1 = 1LB .

Dans l’exemple précédent, l’ensemble = {3 4 5}. Le problème se ramène effectivement à


H , ,

ordonnancer ces tâches car l’ordonnancement des autres tâches est trivial d’après les proposition 5
et 6. Nous remarquons que ne donne pas la solution optimale si on s’intéresse à séquencer
F IF O

les tâches de . La règle


H donne le séquencement (3 4 5) et un max = 16 La séquence
F IF O , , C .

optimale est (3 5 4) avec un Cmax = 15. Il est intéressant d’évaluer la performance de cette
, ,

heuristique d’une manière générale. C’est ce qu’on présente dans la suite.


Définition 14 Soit π un problème d’ordonnancement. On dit que l’heuristique H a un rapport
H (I ) ≤ α, I est une instance de P .
de garantie absolue α au pire cas si on a : α = max α/ opt(I )

Proposition 10 Dans le cas du problème 1, h1 |ri |Cmax, si le rapport de garantie absolue α au

pire cas de FIFO existe, alors il est supérieur ou égal à 2.

α (FIFO ) ≥ 2

Preuve. Considérons l’instance suivante formée de deux tâches J = {1, 2} avec p1 = 1, p2 =


T − ε, r1 = 0, r2 = ε, T1 = T et T2 = T + 1.

135
1 2

0 1 T T+ 1 2T+1-ε

F . 5-2: Solution donnée par FIF O

2 1

0 ε T T+ 1 2
T+

F . 5-3: Solution optimale

ε ∈ ]0, 1[et T est choisi très grand.


L’application de F IF O donne le séquencement (1, 2) représenté dans la figure 5-2. Le makespan
Cmax (F IF O) = 2T + 1 − ε.
En revanche, la solution optimale est (2, 1) . Dans ce cas le makespan optimal Cmax (opt) = T +2
(voir figure 5-3).
Pour cet exemple, le rapport α = 2TT+1−
+2 Si on tend T vers l’infini, α tend vers 2. Ceci montre
ε
.

que α ne peut être strictement inférieur à 2. D’où α (FIF O) ≥ 2 .

Lemme 15 α (F IFO) existe et vaut exactement 2.


Preuve. Pour démonter ce résultat, nous allons prouver que Cmax (F IF O) ≤ 2Cmax (opt) pour
toute instance du problème.
Soit δ l’écart entre la dernière tâche ordonnancée dans F IF O avant l’indisponibilité et la date
T1 (voir figure5-4).

Il est assez simple de remarquer que Cmax (F IF O) − Cmax (opt) ≤ δ. De plus, Cmax (opt) > δ
pour toute instance. D’où le résultat.
Conséquence : Si δ = 0 , F IF O est optimale.
Dans la suite, nous allons nous intéresser à la résolution pratique de ce problème en se basant
sur certaines propriétés développées dans cette section.

136
δ

... ...

0 T1 T2

F . 5-4: Définition de δ

5.3 Trois méthodes exactes


Dans cette section, nous proposons trois approches exactes pour résoudre le problème. La
première approche est l’algorithme de séparation et d’évaluation basé sur les différentes propriétés
et les résultats présentés précédemment. La deuxième approche est une méthode de programmation
linéaire en nombres entiers (PLNE). La dernière méthode est une programmation dynamique. Dans
la suite, nous donnons une description de chacune de ces méthodes.

5.3.1 Procédure de séparation et d’évaluation (PSE)

Basée sur la borne inférieure LB1, nous allons proposer un algorithme de séparation et d’éva-
luation (branch and bound algorithm) pour résoudre le problème. Les tâches sont triées selon
l’ordre FIFO. Il est évident que, dans la solution optimale, l’ensemble des tâches effectuées avant
le début de la maintenance (avant T1) sont ordonnancées selon la règle FIFO. La même propriété
est valable aussi pour l’ensemble des tâches effectuées aprés la période de maintenance (après T2).
Pour cette raison, le noeud est caractérisé par les éléments suivants dans l’algorithme proposé :
◦ le niveau k qui représente le nombre des tâches ordonnancées,
◦ l’affectation partielle des tâches ordonnancées : A = {x1,x2, ..., xk } avec x ∈ {0, 1} ∀i ≤ k
i

telle que : x = 1 si la tâche i est ordonnancée avant la date T1 et x = 0 si la tâche i est


i i

ordonnancée après la date T2,


◦ la borne inférieure LB1 de la section précédente.
La borne supérieure est calculée à l’aide de la règle FIFO. Dans l’étape de sparation, nous
avons deux possibilités : ordonnancer la tâche (k + 1) avant T1 (dans ce cas, xk+1 = 1) ou après

137
T2 (xk+1 = 0). Après le calcul de la borne inférieure, le noeud est supprimé de la liste active si la
valeur de la borne inférieure est supérieure ou égale à la borne supérieure courante.

5.3.2 Programmation linéaire en nombres entiers (PLNE)


Dans ce paragraphe, nous proposons un modèle linéaire en nombres entiers afin de tester sa
performance pour le problème étudié. Un tel modèle peut être décrit comme suit :
Minimize Cmax
Sous les contraintes :
Cmax ≥ Ci ∀1 ≤ i ≤ N

C ≥ (1 − x ) · T2 + =1 p − =1 x · p ∀1 ≤ i ≤ N
i i
i
j j
i
j j j

C ≥ r + p ∀1 ≤ i ≤ N
i i i

C ≥ v + =1 x · p ∀1 ≤ i ≤ N
i i
i
j j j

v ≥ v −1 ∀2 ≤ i ≤ N
i i

v ≥ C − (1 − x ) · T2 + =1 − =1 ·
i i i
i
j pj ∀1 ≤ ≤i
j xj pj i N

xi ∈ {0, 1} ∀1 ≤ i ≤ N
vi ≥0 ∀1 ≤ i ≤ N
Ci ≥0 ∀1 ≤ i ≤ N
avec x = 1 si la tâche i est ordonnancée avant T1 et x = 0 si la tâche i est ordonnancée
i i

après T2. Nous désignons par C la date de fin de la tâche i. La variable v représente la durée
i i

totale de la non occupation de la machine entre t = 0 et la date de début de la tâche i si elle est
ordonnancée avant T1. Si i est ordonnancée après T2, alors v prend la valeur de v −1. Notons que
i i

v1 est initialisé à 0.

5.3.3 Programmation dynamique


Le problème est de trouver la partition des tâches en deux sous-ensemble Ω1 et Ω2 telles que
les tâches du sous ensemble Ω1 sont ordonnancées avant la période de maintenance et le reste
des tâches de Ω2, sont ordonnancées après la période de maintenance. L’idée principale de cet
algorithme est de trouver le sous ensemble Ω1 qui garantit le remplissage au maximum de la
partie entre la date t = 0 et la date t = T1.
138
Nons supposons que les tâches soient indexées suivant l’ordre non-décroissant de leurs dates de
début au plus tôt. A cause de la dominance de la règle F IF O, les tâches de chaque sous-ensemble
doivent être ordonnancées dans l’ordre non-décroissant de leurs indexations.
Soit σ(i, R) la plus grande somme des durées opératoires des tâches affectées avant T1 de
l’ensemble {1 2 . . . , i} où R est la date de fin d’exécution de la dernière tâche de Ω1 (0 ≤ R ≤ T1).
, , ,

Si une telle solution n’existe pas, on pose σ(i, R) = −∞. La formulation dynamique du problème
peut être écrite comme suit :

 σ(i − 1, R)

σ (i, R) = max  σ(i − 1, R − p ) + p si R − pi ≥ ri (5.1)
 i i

 −∞ si R − pi < ri
avec σ(0, 0) = 0, σ (0, R) = −∞ ∀R > 0 avec 0 ≤ R ≤ T1 et σ∗ = max0≤R≤T 1 σ (N, R).
Le makespan optimal de notre problème est donc :
N
C

max = T2 + pi − σ ∗ (5.2)
i=1

5.4 Etude expérimentale


Nous avons implementé l’algorithme de séparation et d’évaluation et celui de programmation
dynamique en langage C et nous les avons testés sur trois séries d’instances. Le modèle linéaire en
nombres entiers a été également testé avec le logiciel CPLEX pour les mêmes séries de problèmes.
Les trois séries ont été générées aléatoirement selon la loi de distribution uniforme :
◦ La série 1 est caractérisée par : p ∈ [1i , 30] .

◦ La série 2 est caractérisée par : ∈ [1


pi , 100] .

◦ La série 3 est caractérisée par : ∈ [1


pi , 150] .

◦ Les dates d’arrivée des tâches sont générées comme suit : 1 = 0 et ∈ [ −1 r −1 + p −1 − 1]


ri r ri U ri , i i

pour tout 1 ≤ < i N.

◦ Les dates de début et de fin de la tâche de maintenance 1 et 2 sont générées comme suit :


T T

T1 ∈ [Z, M ] avec = Ni=1 pi et = max M2 maxi ( i + i) et 2 ∈ [T1 1 + 100]


M Z , r p T ,T .

139
Les différents résultats sont reportés dans les tableaux 5.2, 5.3 et 5.4. Pour chaque méthode,
on fournit le temps d’execution. La colonne “ ” indique la meilleure solution trouvée avant
best of

l’arrêt du programme. Dans le cas de l’algorithme de séparation et d’évaluation et de celui de


programmation linéaire, nous indiquons aussi le nombre des noeuds explorés avant l’arrêt de l’exé-
cution du programme. Selon ces résultats, il est clair que l’algorithme de séparation et d’évaluation
est plus performant que la programmation linéaire en nombres entiers. C’est la même observa-
tion pour la programmation dynamique. On peut remarquer que le temps de calcul et le nombre
des noeuds visités avant l’arrêt de la branch and bound sont largement inférieurs à ceux de la
programmation linéaire en nombres entiers (voir figure 5-5). Practiquement, la PLNE n’est pas
capable de résoudre des problèmes de taille supérieure à 40 tâches. D’un autre côté, la program-
mation dynamique est capable de résoudre des problèmes jusqu’à 3000 tâches et ne conduit pas à
des problèmes de mémoire. Pour l’algorithme de séparation et d’évaluation, les résultats obtenus
semblent plus performants que les deux autres méthodes. En effet, cette méthode peut résoudre
des problèmes d’une taille avoisinant les 20000 tâches.

45000,00
40000,00
35000,00
30000,00
temps (s)

B&B
25000,00
LP
20000,00
DP
15000,00
10000,00
5000,00
0,00
5 10 15 20 25 30 35 40
n

F . 5-5: Comparaison des temps de calcul des trois méthodes

5.4.1 Comparaison de la borne linéaire avec la borne LB1


Pour expliquer la différence entre les performances des deux méthodes, nous avons comparé la
performance de la borne inférieure LB1 et de la borne LBLP (la borne inférieure obtenue par la

140
relaxation de la contarinte d’intégrité dans la PLNE). Ces bornes inférieures ont été calculées pour
les trois séries mentionnées précédement. Les différents résultats (en moyenne) sont présentés dans
le tableau 5.5. Nous pouvons ainsi expliquer la performance de la branch and bound. En effet, la
valeur de la borne inférieure LB1 est couramment égale à la solution optimale ou très proche pour
la plupart des instances testées. En plus, la borne linéaire est toujours très faible et par la suite
mène à un nombre considérable de noeuds et à plus du temps de calcul (voir figure 5-6).

Comparaison des ratios des bornes inférieures

120,00

100,00

80,00
Ratio (%)

Ratio LB1
60,00
Ratio LB(LP)
40,00

20,00

0,00
0
0

0
0

0
5
15

25
35

45
10
30

50
70

90

F . 5-6: Comparaison des ratios des bornes inférieures

5.4.2 Comparaison entre la branch and bound et la programmation


dynamique
Les différents résultats sont reportés dans les tables 5.2 et 5.4. Suivant ces résultats, on peut
conclure que la méthode de séparation et d’évaluation est plus performante que celle de pro-
grammation dynamique pour les différentes simulations. En effet, elle est capable de résoudre des
problèmes de 20000 tâches de taille. Le temps de calcul de l’algorithme de séparation et d’évalua-
tion est toujours inférieur à celui de la programmation dynamique. La performance de la méthode
est donc incontestable.

141
4500,00
4000,00
3500,00
3000,00

temps (s) 2500,00 DP


2000,00 B&B

1500,00
1000,00
500,00
0,00
0 1000 2000 3000 4000
n

F . 5-7: Comparaison des temps de calcul pour la B&B et la PD

5.5 Conclusion

Dans ce chapitre, nous avons considéré le problème d’ordonnancement sur une machine avec la
contrainte d’indisponibilité indépendante. Le critère étudié est le makespan. Nous avons proposé
une borne inférieure et avons étudié les propriétés mathématiques du problème. Trois méthodes
exactes ont été présentées : une programmation linéaire en nombres entiers, une branch and bound
et une programmation dynamique. Les résultats expérimentaux ont été également présentés et
discutés. L’efficacité de ces approches a été étudiée à travers ces résultats.

142
T . 5.2: Résultats obtenusen utilisant l’algorithme de séparation et d’évaluation
Série 1 Série 2 Série 3
n Bestof Temps Nodes Bestof Temps Nodes Bestof Temps Nodes
5 121 0,00 13 229 0,00 10 308 0,00 12
10 182 0,00 39 500 0,00 67 724 0,00 53
15 281 0,00 87 803 0,00 83 1173 0,00 56
20 419 0,00 224 1200 0,00 145 1756 0,00 146
25 480 0,00 54 1423 0,00 380 2097 0,00 101
30 555 0,00 84 1717 0,00 241 2547 0,00 174
35 673 0,00 143 2070 0,00 206 2067 0,00 112
40 780 0,00 2 2374 0,00 154 3511 0,00 196
45 901 0,00 99 2693 0,00 364 3972 0,04 331
50 975 0,00 2 2950 0,00 2 4361 0,00 94
100 1755 0,00 200 5561 0,01 200 8276 0,01 201
200 3432 0,00 2 10801 0,02 378 16068 0,00 2
300 5002 0,00 2 15798 0,04 836 23511 0,00 2
400 6441 0,05 789 20381 0,05 794 30347 0,00 2
500 7952 0,00 2 25136 0,00 2 37421 0,63 1053
600 9541 0,00 2 30238 0,14 1460 45031 0,00 2
700 11243 0,15 1474 35607 0,14 1363 53016 0,18 1681
800 12827 0,00 2 40739 0,00 2 60686 0,87 1593
900 14335 0,28 1989 45406 0,00 2 67622 0,00 2
1000 15939 0,30 2053 505572 0,28 2029 75339 0,01 2
1100 17517 0,63 3223 55666 0,35 2171 82943 0,96 2068
1200 19212 0,50 2813 61030 0,40 2360 90934 0,99 90834
1300 20967 0,49 2595 66624 0,48 2557 99266 0,96 2470
1400 22579 0,00 2 71814 0,54 2709 107010 0,51 3633
1500 24277 0,00 2 77167 0,68 2987 114965 0,00 2
2000 31986 1,96 6186 101899 0,00 2 151848 0,00 2
2500 40072 2,02 5592 127635 3,83 4953 190181 0,00 2
3000 47991 15 47991 152879 0,00 2 227800 0,00 2
4000 63935 0,00 2 203760 84,48 7266 303653 90,2 7252
5000 79566 0,00 2 253398 0,00 2 377589 0,00 2
6000 95272 0,00 2 303280 0,00 2 415904 95,1 3886
7000 111054 0,00 2 353520* 68,1 3290 526778 89,6 3284
8000 127153 0,00 2 404912* 91,8 2877 603382 0,00 2
9000 143210 0,00 2 456306* 91 2555 680018 0,00 2
10000 159416 0,00 2 507911* 94 2300 756942 0,00 2
15000 240666 0,00 2 766961 0,00 2 1143020 101,7 1520
20000 319503* 103,8 1170 1018143 0,00 2 1517290 0 2

143
T . 5.3: Résultats obtenus en utilisant la programmation linéaire en nombres entiers

Série 1 Série 2 Série 3


n Bestof Temps Nodes Bestof Temps Nodes Bestof Temps Nodes
5 121 0,00 13 229 0,00 10 308 0,01 12
10 182 0,02 39 500 0,02 67 724 0,02 53
15 281 0,03 87 803 0,04 83 1173 0,04 56
20 419 0,05 224 1200 0,05 145 1756 0,08 146
25 480 0,13 54 1423 0,10 380 2097 0,12 101
30 555 1,27 84 1717 1,56 241 2547 1,28 174
35 673 89,2 143 2070 49,8 206 2067 52,9 112
40 >9 h 2374 1925 154 >9 h

144
T . 5.4: Résultats obtenus en utilisant la programmation dynamique

Série 1 Série 2 Série 3 Moyenne


n Bestof Temps Bestof Temps Bestof Temps Bestof Temps
5 121 0.00 229 0.00 308 0.00 219 0.00
10 182 0.00 500 0.00 724 0.01 469 0.00
15 281 0.00 803 0.00 1173 0.01 752 0.00
20 419 0.00 1200 0.00 1756 0.01 1125 0.00
25 480 0.00 1423 0.04 2097 0.04 1333 0.03
30 555 0.00 1717 0.05 2547 0.02 1606 0.02
35 673 0.01 2070 0.06 2067 0.03 1937 0.03
40 780 0.06 2374 0.03 3511 0.07 222 0.05
45 901 0.08 2693 0.06 3972 0.07 2522 0.07
50 975 0.05 2950 0.09 4361 0.06 2762 0.07
100 1755 0.09 5561 0.28 8276 0.42 5197 0.26
200 3432 0.40 10801 1.21 16068 1.85 10100 1.15
300 5002 1.11 15798 3.40 23511 5.13 14770 3.21
400 6441 2.15 20381 6.83 30347 10.22 19056 6.40
500 7952 4.66 25136 14.6 37421 21.97 23503 13.77
600 9541 6.95 30238 21.7 45031 32.63 28270 20.45
700 11243 18.1 35607 57.4 53016 86.10 33289 53.92
800 12827 30.3 40739 96 60686 381.4 38084 169.2
900 14335 38 45406 120.5 67622 181 42454 113.2
1000 15939 52.3 505572 165.1 75339 247.8 47283 155.1
1100 17517 49.5 55666 154.3 82943 231.8 52042 145.2
1200 19212 81.1 61030 258.2 90934 385.5 57059 241.6
1300 20967 97.8 66624 309.8 99266 465.2 62286 290.9
1400 22579 114.3 71814 362.2 107010 544.4 67134 340.3
1500 24277 130.4 77167 413.1 114965 728.2 72136 423.9
2000 31986 265.6 101899 846.6 151848 1262 95244 791.6
2500 40072 1097 127635 2046 190181 3064 119296 2069
3000 47991 1329 152879 4211 227800 6469 142890 4003

145
T . 5.5: Résultats des bornes inférieures LB1 et LBLP

n LB1 LBLP Bestof Ratio LB1 Ratio LBLP


5 216 94 219 98.63 42.71
10 468 288 469 99.93 61.52
15 751 411 752 99.87 54.59
20 1125 606 1125 99.97 53.90
25 1333 713 1333 100.00 53.48
30 1606 871 1606 100.00 54.20
35 1937 983 1937 100.00 50.77
40 2222 1060 2222 100.00 47.70
45 2522 1248 2522 100.00 49.47
50 2762 1395 2762 100.00 50.49
100 5197 2549 5197 100.00 49.04
200 10100 4542 10100 100.00 44.97
300 14770 6461 14770 100.00 43.74
400 19056 9150 19056 100.00 48.02
500 23503 10884 23503 100.00 46.31
600 28270 13467 28270 100.00 47.64
700 33289 16037 33289 100.00 48.17
800 38084 18857 38084 100.00 49.52
900 42454 20397 42454 100.00 48.04
1000 47283 23148 47283 100.00 48.96

146
Conclusion générale

Dans ce mémoire, nous avons étudié des problèmes d’ordonnancement avec prise en compte de
la notion d’indisponibilité de ressource. Cette notion peut être dépendante des tâches à réaliser
(cas par exemple des problèmes avec des temps de préparation). Elle peut aussi être indépendante
des tâches (cas d’une maintenance planifiée).
Le travail bibliographique réalisé a montré l’intérêt de prendre en compte cette notion dans
l’étape de l’ordonnancement. En effet, les nombreuses situations industrielles qui imposent ce type
de contrainte ont motivé les chercheurs à se lancer dans leur étude. D’autre part, les riches résultats
de la littérature sur des problèmes similaires nous ont encouragé à choisir les méthodes exactes
comme approches de résolution. Nous avons donc conclu à la nécessité d’étudier l’adaptabilité de
ces techniques à de tels problèmes.
Dans cette optique, nos travaux s’articulent autour de deux parties. La première partie étu-
die le cas des setup times. La deuxième partie traite de l’indisponibilité liée à une activité de
maintenance. Ainsi, plusieurs problèmes ont été étudiés.
Le premier problème abordé dans la première partie est celui de la minimisation de la somme
des retards sur une machine unique avec des temps de setup dépendants de la séquence des
tâches. Une méthode exacte du type branch and bound a été conçue. Cette méthode est basée
sur deux bornes inférieures, plusieurs heuristiques et quelques propriétés de dominance. Elle a
permis d’améliorer significativement les résultats de la littérature. Cette étude a permis ensuite
d’aborder deux autres problèmes : la minimisation de la somme des dates de fin et la minimisation
du retard total sur machines parallèles. Pour que notre approche soit efficace, nous avons adapté
les différentes propriétés établies suivant les spécificités des deux problèmes. En effet, nous avons

147
développé des heuristiques plus spécifiques et plus efficaces. Les résultats expérimentaux sont
intéressants et montrent bien l’adéquation de notre approche.
Dans la deuxième partie, nous avons abordé le cas d’indisponibilité indépendante à travers
deux problèmes avec une seule indisponibilité. D’une part, nous avons étudié le problème de mini-
misation de la somme pondérée des dates de fin d’exécution. D’autre part, le critère de makespan
a été étudié dans le dernier chapitre.
D’un point de vue méthodologique, les approches développées dans le cadre de ce mémoire ont
été bien variées. En effet, trois types d’approche exacte ont été envisagés. D’une part, quelques
problèmes étudiés ont été modélisés sous forme de programmes linéaires en nombres entiers tout en
testant ces modèles numériquement. D’autre part, plusieurs variantes de méthodes arborescentes
ont été conçues. Enfin, deux problèmes traités ont été résolus par la programmation dynamique.
Ces méthodes développées (en particulier la branch and bound et la programmation dynamique)
s’avèrent efficaces et capables de résoudre des problèmes de taille importante dans plusieurs cas.
Les résultats que nous avons obtenus sont prometteurs et encourageants. Il serait donc inté-
ressant de développer certains aspects dans les travaux futurs que nous envisageons.
◦ Adaptation des approches développées avec des temps de préparation dépendants au cas
avec des familles des temps de préparation.
◦ Etude d’autres critères pour les problèmes à indisponibilité dépendante comme la somme
pondérée des dates de fin, le nombre (pondéré ou non) des tâches en retard.
◦ Introduction d’autres données à ce type de problème comme les dates d’arrivée ou les durées
de latence.
◦ Généralisation des approches développées avec indisponibilité indépendante au cas des ma-
chines parallèles.
◦ Etude du cas où on est confronté à de multiples et diverses indisponibilités.
◦ Etude des critères de retard pour les problèmes avec indisponibilité indépendante.

148
Bibliographie

[1] Adiri I., Bruno J., Frostig E. and Rinnooy Kan A.H.G., Single machine flow-time scheduling
with a single breakdown. Acta Informatica, 26(1989) 679-696.
[2] Alidaee B. and Rosa D., Scheduling parallel machines to minimize total weighted and un-
weighted tardiness. Computers & Operations Research, 24 (8) (1997) 775-788.
[3] Aggoune R., Ordonnancement dateliers sous contraintes de disponibilité des machines. Ph.D.
Thesis, Université de Metz 2002, France.
[4] Aggoune R., Minimizing the makespan for the flow shop scheduling problem with availability
constraints. European Journal of Operational Research, 153 (2004) 534-543.
[5] Ahmadi R.H. and Bagchi U., Lower bounds for single-machine scheduling problems. Naval
Research Logistics, 37 (1990) 967-979.
[6] Ahn B.H. and Hyun J.H., Single facility multi-class job scheduling. Computers and Opera-
tions Research, 17 (1990) 265-272.
[7] Allahverdi A., Gupta J. N. D. and Aldowaisan T., A review of scheduling research involving
setup considerations. Omega, 27 (1999) 219-239.
[8] Artiba, A., Contribution à la construction d’un système d’aide à la planification et à l’or-
donnancement des lignes parallèles multi-produits. Thèse soutenue le 26 décembre 1990 à
l’université de Valenciennes et du Hainaut-Cambresis.
[9] Azizoglu M. and Kirca O., Tardiness minimization on parallel machines. International Jour-
nal of Production Economics, 55 (1998) 163-168.
[10] Baker K. R., Introduction to sequencing and scheduling, John Wiley, New York, 1974.

149
[11] Baker K. R. and Schrage L. E., Finding an optimal sequence by dynamic programming : an
extension to precedence related tasks. Operations Research, 25 (1978) 111-120.
[12] Baker K. R., Bertrand J. W., A dynamic priority rule for scheduling against due-dates.
Journal of Operational Management, 3 (1982) 37-42.
[13] Baker K. R., Solving the weighted completion time problem with batch setups.Working
Paper 98-118, Amos Tuck School of Business Administration, Dartmouth College, 1998.
[14] Baker K.R., Procedures for sequencing tasks with one resource type, International Journal
of Production Research 11 (1973) 125-138.
[15] Baptiste Ph.,Carlier J. and Jouglet A., A branch-and-bound procedure to minimize total
tardiness on one machine with arbitraryrelease dates. European Journal of Operational
research, 158 (2004) 595-608 .
[16] Barnes W. J. and Brennan J.J., An improved algorithm for scheduling jobs on identical
machines. AIIE Transactions, 9 (1977) 25-31.

[17] Bellman R., Dynamic programming, Princeton University Press, Princeton, N.J., 1957.
[18] Bellman R., Dreyfus S.E., Applied Dynamic programming, Princeton University Press, Prin-
ceton, N.J., 1962.
[19] Berard F., Azzaro-Pantel C., Pibouleau L. and Domenech S., Résolution de problèmes d’or-
donnancement en génie des procédés. Actes du congrés international Franco-Québécois de
Génie Industriel, Albi 1997.
[20] Bianco L. and Ricciardelli S., Scheduling of single machine to minimize total weighted com-
pletion time subject to release dates. Naval Research Logistics Quarterly, 29 (1982) 151-167.
[21] Blazewicz J., Ecker K. H., Pèsch E., Schmidt G., and Wèglarz J., Scheduling computer and
manufacturing Process. Springer-Verlag, Berlin, Heidelberg, 1996.
[22] Blazewicz J., Breit J., Formanowicz P., Kubiak W. and Schmidt G., Heuristic algorithms
for two-machine flowshop with limited machine availability, Omega, 29 (2001) 599-608.
[23] Bonneville F., Perrard C. and Henrioud J. M., A genetic algorithm to generate and evaluate
assembly plans. Actes du congrès IEEE, (1995) 231-239.
150
[24] Breit J., An improved approximation algorithm for two-machine flow shop scheduling with
an availability constraint. Information Processing Letters, 90 (2004) 273-278.
[25] Breit J., Schmidt G. and Strusevich V. A., Two-machine open shop scheduling with an
availability constraint. Operations Reseach Letters, 29 (2001) 65-77.
[26] Carlier J. et Chrétienne P., Problèmes d’ordonnancement : modélisation / complexité /
algorithmes, Masson, Paris, 1988.
[27] Chandra R., On n/1/F Dynamic Deterministic Problems. Naval Research Logistics Quar-
terly, 26 (1979) 537-544.
[28] Chang S.Y. and Hwang H. C., The worst-case analysis of the MULTIFIT algorithm for sche-
duling non-simultaneous parallel machines, Discrete Applied Mathematics, 92 (2-3) (1999)
135-147.
[29] Charon I.,Germa A. et Hudry O., Méthodes d’optimisation combinatoire, Masson, Paris,
1996.
[30] Cheng T. C. E. and Wang G., An improved heuristic for two-machine flowshop scheduling
with an availability constraint. Operations Reseach Letter, 26 (2000) 233-229.
[31] Chu C., Efficient heuristics to minimize total flow time with release dates. Operations Re-
search Letters, 12 (1992) 321-330.
[32] Chu C., A branch-and-bound algorithm to minimize total flow time with unequal release
dates. Naval Research Logistics, 39 (1992) 859-875.
[33] Chu C., A branch-and-bound to minimize total tardiness with different release dates, Naval
Research Logistics, 39 (1992) 265-283.
[34] Chu C., Ordonnancement de la production : Approches théoriques nouvelles, HDR, Univer-
sité de Metz, 1995.
[35] Chu C., Proth J. M., L’ordonnancement et ses applications, série sciences de l’ingenieur,
Collection Organisation Industrielle, Masson, Paris, 1996.
[36] Chu C. and Portmann M. C., Some new efficient methods to solve the n/1/r / i Ti schedu-
ling problem, European Journal of Operational Research, 58 (1991) 404-413.

151
[37] Crauwels HAJ, A comparative study of local search methods for one-machine sequencing
problems. Ph.D. Thesis, De. Nayer Institute, Belgium, 1998.
[38] Crauwels HAJ, Potts C. N. and Van Wassenhove L.N., Local search heuristics for single
machine scheduling with batch setup times to minimize total weighted completion time.
Annals of Operations Research, 70 (1997) 261-79.
[39] S. Dauzère-Pérès, W. Roux and J. B. Lasserre, Multi-resource shop scheduling with resource
flexibility, European Journal of Operational Research, Volume 107, Issue 2, 1 June 1998,
Pages 289-305.
[40] Davis L., The genetic algorithm HandBook. Ed. New York : Van Nostrand Reinhold, ch. 17,
1991.
[41] Della Croce F., T’kindt V., Improving the preemptive bound for the one machine total
completion time scheduling problem. Operations Research Letters, 2003.
[42] Dell’Amico M., Martello S., Vigo D., Minimizing the sum of weighted completion times with
unrestricted weights. Discrete Applied Mathematics, 63 (1995) 25-41.
[43] Deogun J.S., On scheduling with ready times to minimize mean flow time. Computer Journal,
26 (1983) 320-328.
[44] Dessouky M.I. and Deogun J.S., Sequencing jobs with unequal ready times to minimize
mean flow time. SIAM Journal on Computing, 10 (1981) 192-202.
[45] Dogramaci A., Production scheduling of independent jobs on parallel identical machines.
International Journal of Production Research 16 (1984) 535-548.
[46] Dogramaci A. and Surkis J., Evaluation of a heuristic for scheduling independent jobs on
parallel identical processors. Management Science 25 (1979) 1208-1216.
[47] Du J., Leung Joseph Y.T., Minimizing total tardiness on one machine is NP-hard. Mathe-
matics of Operations Research, 15 ( 3) (1990) 483-495.
[48] Dunstall S., A study of models and algorithms for machine scheduling problems with setup
times. Ph.D. Thesis,University of Melbourne, Australia, 2000.
[49] Dunstall S., Wirth A. and Baker K. R., Lower bounds and algorithms for flowtime minimi-
zation on a single machine with set-up times. Journal of Scheduling, 3 (1) (2000) 51-69.
152
[50] Elmaghraby S.E. and Park S.H., Scheduling jobs on a number of identical machines, AIIE
Transactions, 6 (1974) 1-13.
[51] Emmons H., One-Machine sequencing to minimize certain functions of job tardiness. Ope-
rations research, (1969) 701-715.
[52] Erscher J., Merce C., Consistency of the dissaggregation process in hierarchical planning.
Operation research, 34 (1985) 464-469.
[53] Esquirol P. et Lopez P., L’ordonnancement, Economica, Paris, 1999.
[54] Esrock Y.P., The impact of reduced setup time. Production and Inventory Management, 26
(1985) 94-100.
[55] Falkenauer E. and Bouffouix S., A genetic algorithm for job shop. In Proceedings of the
IEEE International Conference on Robotics and Automation, (1991) 824-829.
[56] Flipo-Dhaenens C., Optimisation d’un réseau de production et de distribution, Thèse de
doctorat, Institut National Polytechnique de Grenoble, Grenoble, 1998.
[57] Garey M. R. and Johnson D. B., Computers and Intractability : A Guide to the Theory of
NP-Completeness. W. H. Freeman and Company (1979), New York.
[58] Gaury E. G. A and Pierreval H., Evolutionary optimization of a generic model to select
pull control strategy. International Conference on Industrial Engineering and Production
Managment, Tome1 (1997) 541-550.
[59] Gero J. S. and Jo J. H., Space Layout planning using an evolutionary approach. Artificial
Intelligence in Engineering, 12 (1998) 149-162.
[60] Ghedjati-Guessoum F., Résolution par des heuristiques dynamiques et des algorithmes géné-
tiques du problème d’ordonnancment de type job-shop généralisé (à machine non identiques
en parallèle et contraintes de précédence), Thèse de doctorat, Univesité Paris 6, Paris, 1994.
[61] Ghosh J. B., Batch scheduling to minimize total completion time. Operations Research
Letters, 16 (1994) 271-275.
[62] Gilmore M. and Smith D.J., Set-up reduction in pharmaceutical manufacturing : an action
research study. International Journal of Operations and Production Management, 16 (3)
(1996) 4-17.
153
[63] Glover F., Tabu serch methods in artificial intelligence and opérations research, ORSA,
Artificial Intelligence New letter, 1, no. 2, 1987.
[64] Goldberg D. E., Genetic algorithms in search, optimization and machine learning. Addison
Wesley, Jan.1989.
[65] Van Goubergen D. and Van Landeghem H., Rule for integrating fast changeover capabilities
into new equipement design. Robotics and Computer Integrated Manufacturing, 18 (2002)
205-214.
[66] Gourgand M., Grangeon N., and Norre S., A contribution to the stochastic flow shop schedu-
ling problem, European Journal of Operational Research, Volume 151, Issue 2, 1 December
2003, Pages 415-433.
[67] Graham R. L., Lawler E. L., Lenstra J. K., and Rinnooy Kan A. H. G., Optimisation and
approximation in deterministic sequencing and scheduling, Annals of discrete Mathematics
4 (1979), 287-326.
[68] Graves G. H. and Lee C. Y., Scheduling maintenance and semi resumable jobs on a single
machine. Naval Research Logistics, 46 (1999) 845-863.
[69] Gropetti R. and Muscia R., On a genetic multiobjective approach for the integration and
optimization of an assembly product design and process planning. Actes IDMME (1997)
61-70.
[70] Gupta J. N. D., Single facility scheduling with multiple job classes. European Journal of
Operational Research, 8 (1988) 42-45.
[71] Gupta J. N. D., Optimal schedule for single facility with two job classes. Computers and
Operations Research, 11 (4) (1984) 409-413.
[72] Haouari M., and M’Hallah R., Heuristic algorithms for the two-stage hybrid flowshop pro-
blem, Operations Research Letters, Volume 21, Issue 1, August 1997, Pages 43-53
[73] Hay E.J., Any machine setup time can be reduced by 75\%. Industrial Engineering, 19 (8)
(1987) 62-67.
[74] Ho J. C. and Chang Y.L., Heuristics for minimizing mean tardiness for m parallel machines.
Naval Research Logistics 38 (1991) 367-381.
154
[75] Ho Y.-C. and Moodie C. L., Machine layout with a linear single-row flow path in an auto-
mated manufacturing system. Journal of Manufacturing System, 17 (1) (1998) 1-22.
[76] Holland J. H., Adaptation in natural and artificial systems. MIT Press, 1975.
[77] Hoogeveen J.A., Van de Velde S.L., Minimizing total completion time and maximum cost
simultaneously is solvable in polynomial time. Operation research letters, 17 (1995) 205-208.
[78] Hwang H. C. and Chang S.Y., Parallel machines scheduling with machine shutdowns. Com-
puters & Mathematics with Applications, 36 (3) (1998) 21-31.
[79] Islier A. A., A genetic algorithm approach for multiple criteria facility layout design. Inter-
national Journal of Production Research, 36 (6) (1998) 1549-1569.
[80] Jouglet A., Ordonnancer une machine pour minimiser la somme des coûts. Thèse de doctorat,
Chapitre 3, (2002) 119-145.
[81] Jouglet A., Ordonnancer une machine pour minimiser la somme des coûts, Univesité de
Technologie de Compiègne, Compiègne, 2002.
[82] Kacem I., Ordonnancement Multicritère des job-shops flexibles : Formulation, bornes infé-
rieures et approche evolutionniste cooperative, Thèse de doctorat, Ecole Centrale de Lille,
Lille, 2003.
[83] Kacem I. and Chu C., Minimizing the sum of the weighted completion times for single
machine with availability constraint. ISTIT-OSI-2004-06, University of technology of Troyes,
France, June 2004.
[84] I. Kacem, and C. Chu, Worst case performance analysis of WSPT and MWSPT for
1 h1
, ||w C IESM 2005, Marrakech, Maroco.
i · i,

[85] I. Kacem, C. Chu, A. Souissi, Minimizing the weighted sum of completion times with availa-
bility constraint : compaison of branch and bound method and integer linear programming,
IESM 2005, Marrakech, Maroco.
[86] I. Kacem, C. Chu, A. Souissi, Single machine scheduling with an availability constraint
to minimize the weighted sum of completion times, Computers & Oprations Research, In
Revision, 2005.

155
[87] Kazerooni M., Luong L. H. S. and Abhary K., A genetic algorithm based cell design conside-
rate alternative routing. Computer Integrated Manufacturing Systems, 10 (2) (1997) 93-107.
[88] Kirkpatrik S., Gerllat C. D. and Vechi M. P., Optimisation by simulated anneling, Science,
220 (1983) 671-680.
[89] Koulamas C., Decomposition and hybrid simulated annealing heuristics for the parallel-
machine total tardiness problem. Naval Research Logistics 44 (1997) 109-125.
[90] Koulamas C., The total tardiness problem review and extensions. Operations Research, 42
(1994) 764-775.
[91] Kubiak, W., Blazewicz, J., Formanowicz, P., Breit. J., and Schmidt, G., (2002). Two-machine
flow shops with limited machine availability. European Journal of Operational Research, 136,
528-540.
[92] Lawler E. L., Lenstra J. K., Rinnooy Kan A. H. G. and Shmoys D. B., Eds., The Traveling
Salesman Problem. John Wiley & Sons, 1985.
[93] Lawler E.L., A pseudopolynomial algorithm for sequencing jobs to minimize total tardiness.
Annals of Discrete Mathematics, 1 (1977) 331-342.
[94] Lawler E. L., On scheduling problem with deferral costs. Management Science 11 (1964)
280-288.
[95] Lawler E. L., A pseudopolynomial algorithm for sequencing jobs to minimizing total tardi-
ness. Annals of Discrete Mathematics, 1 (1977) 280-288.
[96] Lee C.-Y., Parallel machine scheduling with non-simultaneous machine available time. Dis-
crete Applied Mathematics. 30 (1991) 53-61.
[97] Lee C. Y., Minimizing the makespan in the two machine flowshop scheduling problem with
an availability constraint. Operations Research Letter, 20 (3) (1997) 129-139.
[98] Lee C. Y., Two machine flowshop scheduling with availability constraints. European Journal
of Operational Research, 114 (1999) 420-429.
[99] Lee C.-Y. and Chen Z. L., scheduling of jobs and maintenance activities on parallel machines.
Naval Research Logistics, 47 (2000) 145-165.

156
[100] Lee C.-Y., Machine scheduling with an availability constraint. Journal of Global Optimiza-
tion, 9 (1996) 363-382.
[101] Lee C. Y., He Y. and Tang G., A note on ”Parallel machine scheduling with non-simultaneous
machine available time”. Discrete Applied Mathematics, 100 (1-2) (2000) 133-135.
[102] Lee C.-Y. and Liman S.D., Capacitated two-parallel machines scheduling to minimize sum
of job completion times, Discrete Applied Mathematics 41 (1993) 211-222.
[103] Lee C.-Y. and Liman S. D., Single machine flow-time scheduling with scheduled maintenance.
Acta Informatica, 29 (1992) 375-382.
[104] Lenstra J. K., Rinnooy Kan A. H. G. and Brucker P., Complexity of machine scheduling
problems. Annals of Discrete Mathematics, 1 (1982) 343-362.
[105] Lewis H. R., Papadimitriou C.H., Elements of the theory of computation, Prentice Hall,
Englewood Cliffs, N.J., 1981.
[106] Liao C.-J. and L. M. Liao, Single facility scheduling with major and minor setups. Computers
and Operations Research, 24 (2) (1997) 169-178.
[107] Liao C.-J., Shyur D.-L. and Lin C.-H., Makespan minimization for two parallel machines with
an availability constraint. European Journal of Operational Research, 160 (2005) 445-456.
[108] Little J. D. C., Murty K. G., Sweeney W. and Karel C., An algorithm for the traveling
salesman problem, Operations Research, 11 (1963), 972-989.
[109] Lopez P. et Roubellat F.,L’ordonnancement de la production, Hermes, Paris, 2001.
[110] Lorigeon T., BillautJ.-C., and Bouquard J.L., Availability constraint for a single machine
problem with heads and tails. In 8th International Workshop on Project Management and
Scheduling, PMS’2002, pages 240{243, Valencia, Spain, april 2002. ISBN 84-921190-5-5.
[111] Mason A.J. and Anderson E. J., Minimizing flow time on a single machine with job classes
and setup times. Naval Research Logistics, 38 (1991) 333-350.
[112] Miller D. and Pekny J. F., Results drom parallel branch and bound algorithm for the tra-
veling salesman problem, Operation research letters, 8 (1989), 129-135.
[113] Monma C.L. and Potts C. N., On the complexity of scheduling with batch setup times.
Operations Research, 37 (1989) 798-804.
157
[114] Moore J. M., An n job, one machine sequencing algorithm for minimizing the number of
late jobs. Management Science, 15 (1968) 102-109.
[115] Mosheiov G., Minimizing the sum of job completion times on capacitated parallel machines.
Mathematical and Computer Modelling, 20 (1994) 91-99.
[116] Mukhopadhyay S. K., Singh M. K. and Srivastava R., FMS machine loading : a simulated
annealing approach. International Journal of Production Research, 36 (6) (1998) 1529-1547.
[117] Nowicki E. and Zdrzalka S. Single machine scheduling with major and minor setup times :
a tabu search approach. Journal of Operational Research Society 47 (1996) 1054-1064.
[118] Olivier I. M., Smith D. J. and Holland J. C. R., A study of permutation crossover operators
on the travelling salesman problem, Proceeding of the 2nd International Conference on
Genetic Algorithms, Lawrence Erlbaum, (1987) 224-230.
[119] Portman M. C., Méthodes de décomposition spatiales et temporelles rden oonnancement,
RAIRO-APII, 22 (5) (1988), 439-451.
[120] Potts C. N., Scheduling two job classes on a single machine. Computers and Operations
Research, 18 (1991) 411-415.
[121] Potts C. N. , Van Wassenhove L. N. , A branch and bound algorithm for the total weighted
tardiness problem. Operation research, 33 (1985) 363-377.
[122] Potts C.N. and Van Wassenhove L.N., A decomposition algorithm for the single machine
total tardiness problem. Operations Research Letters, 1 (1982) 177-181.
[123] Potts C.N. and Van Wassenhove L.N., Dynamic programming and decomposition approaches
for the single machine total tardiness problem. European Journal of Operational Research,
32 (1987) 404-414.
[124] Rabadi G., Application of constraint programming to a scheduling problem with a common
due date and setup times. First international industrial engineering conference Amman-
Jordan, (2001) 274-284.
[125] Rabadi G., Georgios C.A. and Mollaghasemi M., A hybrid heuristic for the just in time
single machine scheduling problem with setups : a comparison with a simulated annealing
approach. Journal of annals of operations research, (Under review).
158
[126] Ragatz Gary L. A branch-and-bound method for minimum tardiness sequencing on a single
processor with sequence dependent setup times. Proceedings of the twenty-fourth annual
Decision Sciences Institute, (November 1993).
[127] Rubin PA, Ragatz GL. Scheduling in a sequence dependent setup environment with genetic
search. Computers and Operations Research, (1995) 85-99.
[128] Reinelt G., The Traveling Salesman : Computational Solutions for TSP Applications. Lecture
Notes in Computer Science. Springer-Verlag, 1994.
[129] Rinnooy Kan A. H. G., Machine sequencing problem : classification. complexity and com-
putation, (1976) Nijhoff, The Hague.
[130] Root J. G., Scheduling with deadlines and loss functions on k parallel machines. Management
Science, 11 (1965) 460-475.
[131] Sadfi C., Penz B., Rapine C., Blazewicz J. and Formanowicz P., An improved approximation
algorithm for the single machine total completion time scheduling problem with availability
constraints. European Journal of Operational Research, 161 (1) (2005) 3-10.
[132] Sadfi C., Problème d’ordonnancement avec minimisation des encours, Thèse de doctorat,
Institut National Polytechnique de Grenoble, Grenoble, 2002.
[133] Sadfi C. and Yassa O., Parallel machines scheduling problem with availability constraints.
Ninth International Conference on Project Management and Scheduling (PMS 2004), pp
206-209, Nancy 26-28 April 2004, France.
[134] Schmidt G., Scheduling on semi-identical processors. Zeitschrift für Operations Research, 28
(1984) 153-162.
[135] Schmidt G., Scheduling independent tasks with deadlines on semi-identical processors. Jour-
nal of Operational Research Society, 39 (1988) 271-277.
[136] Schmidt G., Scheduling with limited machine availability. European Journal of Operational
Research, 121 (2000) 1-15.
[137] Schrage L. E. and Miller L. W., The queue M/G/1 with the Shortest Remaining Time
Discipline. Operation Research, 14 (3) (1966).

159
[138] Schrage L. E., A proof of the optimality of the Shortest Remaining Processing Time Disci-
pline. Operation Research, 6 (3) (May-June 1968).
[139] Schutten J.MJ., List scheduling revisited. Operations research letters, 18 (1996) 167-170.
[140] Sekine K. and Arai K., Kaizen for quick changeover : going beyond SMED. Productivity
Press, (1992).
[141] Selen W. J. and Heuts R. M. J., Operational production planning in a chemical manufactu-
ring environment. European Journal of Operational Research 45 (1990) 38-46.
[142] Shingo S., A revolution in manufacturing, the SMED system. Productivity Press, 1985.
[143] Smith W.E., Various optimizers for single-stage production. Naval Research Logistics Quar-
terly, 3 (1956) 59-66.
[144] Souissi A., Kacem I. and Chu C., Minimizing total tardiness on a single machine with
sequence-dependent setup times, International Conference on systems, Man and Cybernetics
(IEEE/SMC 2004), The Hague, 10-13 october 2004, Netherland.
[145] Souissi A., Kacem I. and Chu C., New lower bound for minimizing total tardiness on a single
machine with sequence-dependent setup times. Ninth International Conference on Project
Management and Scheduling (PMS 2004), pp 123-127, Nancy 26-28 April 2004, France.
[146] Souissi A., Kacem I. and Chu C., Exact method for minimizing total flow-time on a single
machine with sequence-dependent setup times. IMS 2004, Arles, July 2004, France.
[147] Souissi A., Kacem I. and Chu C., Exact method for minimizing total tardiness on a single
machine with sequence-dependent setup times. Submitted to EJOR, 2004.
[148] Souissi A., Kacem I. and Chu C., Exact method for minimizing total tardiness on parallel
machines with sequence-dependent setup times. Submitted to EJOR, 2005.
[149] Souissi A., Kacem I. and Chu C., Minimiser le makespan sur une machine avec une indis-
ponibilité. Soumis à Roadef’06, Lille 2006.
[150] Souissi A., Kacem I. and Chu C., Minimiser la somme des retards sur parallèles machines
avec des temps de setup dépendants. Actes des articles longs sélectionnés du Congrés de la
Roadef’06, Lille 2006, Presses Universitaires de Valenciennes.

160
[151] Suzaki K., The new manufacturing challenge. The Free Press, New York (1987).
[152] Szwarc W.,Della Croce F. and Grosso A., Solution of the Single Machine Total Tardiness
Problem. Journal of Scheduling, 2 (1999) 55-71.
[153] Tan K.C., Narasimhan R. Minimizing tardiness on a single processor with sequence de-
pendent setup times : a simulated annealing approach. Omega, 25 (6) (1997) 619-34.
[154] Tan K.C., Narasimhan R., Rubin P. A. and Ragatz G. L., A comparison of four methods
for minimizing total tardiness on a single processor with sequence dependent setup times.
Omega, 28 (2000) 313-326.
[155] Tautou L. and Pierreval H., Using evolutionary algorithms and simulation for the optimiza-
tion of manufacturing systems. Actes du congrès IEEE, (1995) 509-524.
[156] Turkcan A., Machine scheduling with availability constraints. Bilkent University, (1999)
Ankara.
[157] Van Goubergen D., Set-Up reduction as an organization-wide problem. Conference IIE So-
lutions 2000. Cleveland, Ohio, USA.
[158] Wang G. and Cheng T. C. E., Heuristic for two-machine no-wait flowshop scheduling with
an availability constraint. Information Processing Letter 80 (2001) 305-309.
[159] Wang G., Sun H. and Chu C., Preemptive scheduling with availability constraints to mi-
nimize total weighted completion times. Annals of Operations Research, 133 (1-4) (2005)
183-192.
[160] Wellman M. A. and Gemmil D. D., A genetic algorithm approch to optimization of asyn-
chronous automatic assembly systems. International Journal of Flexible Manufacturing, 7
(1995) 27-46.
[161] Widmer M., Modèles mathématiques pour un gestion efficace des ateliers flexibles. Presses
Polytechniques et Universitaires Romandes, 1991.
[162] Wilkerson L. J. and Irwin J.D., An improved algorithm for scheduling independent tasks.
AIIE Transactions 3 (1971) 239-245.
[163] Williams D.N. and Wirth A., A new heuristic for a single machine scheduling problem with
setup times. Journal of Operational Research Society, 47 (1996) 175-180.
161
[164] Yalaoui F., Ordonnancement de la production en présence de machines alternatives, Thèse
de doctorat, Univesité de Technologie de Troyes, Troyes, 2000.
[165] Yalaoui F. and Chu C., Parallel machine scheduling to minimize total tardiness. International
Journal of Production Economics 76 (2002) 265-279.
[166] Yanai S. and Fujie T., On a dominance test for single machine scheduling problem with
release date to minimize flow time. The Institute of Economic Research, Kobe University of
Commerce, August 2003.
[167] Zdrzalka S. Analysis of approximation algorithms for single-machine scheduling with delivery
times and sequence independent batch setup times. Journal of the Operations Research
Society, 80 (1995) 371-380.
[168] Zdrzalka S., Approximation algorithm for single-machine sequencing with delivery times and
unit batch set-up times. European Journal of Operational Research, 51 (1991) 199-209.
[169] Zdrzalka S., Preemptive scheduling with release dates, delivery times and sequence inde-
pendent setup times. European Journal of Operational Research, 76 (1994) 60-71.

162

Vous aimerez peut-être aussi