© Vincent Martel, 2019

Intégration d'une fonction de coût à la contrainte Disjunctive utilisée en

ordonnancement

Mémoire

Vincent Martel

Maîtrise en informatique - avec mémoire

Maître ès sciences (M. Sc.)

Québec, Canada

Intégration d’une fonction de coût à la contrainteDisjunctive utilisée en ordonnancement

Mémoire

Vincent Martel

Sous la direction de:

Claude-Guy Quimper

Résumé

La programmation par contraintes est une technique accélérant la recherche de solutions pourdes problèmes d’optimisation combinatoire. Ce mémoire porte sur l’application de cette tech-nique en ordonnancement. Le but est d’intégrer une fonction de coût convexe à la contrainteDisjunctive qui régit l’ordre d’exécution d’un ensemble de tâches ne pouvant pas se chevau-cher dans le temps. Dans ce contexte, le coût est perçu comme un retard déterminé par uneéchéance préférable indiquée pour chaque tâche.

La contribution se traduit en l’introduction de la contrainte DisjunctiveTardiness qui tissede nouveaux liens entre l’ordre d’exécution des tâches et la somme des retards engendrés. Lacohérence de la contrainte est assurée par un algorithme de filtrage. L’algorithme raisonne àpartir de la construction d’un réseau de flot pondéré basé sur la fenêtre d’exécution des tâcheset leur échéance préférable. Il est implémenté dans un solveur et comparé à une alternativecompétitive.

Tel qu’observé, le nouvel algorithme amène un filtrage tangible, mais sa complexité trop élevéeempêche d’aboutir à un nouvel état de l’art en pratique. En revanche, plusieurs pistes desolution pour réduire le temps d’exécution sont proposées.

iii

Abstract

Constraint programming is a technology originating from artificial intelligence that explores asearch space to solve combinatorial problems. It uses filtering algorithms to filter the searchspace and speedup the search of a solution. This master thesis covers an application of thismethod in scheduling. The goal is to integrate a convex cost function to the Disjunctive

constraint that governs the execution order of tasks unable to overlap each other on a timeline. In this context, the cost is treated as a delay (tardiness) computed from a due datespecified for each task.

The contribution translates in a new constraint named DisjunctiveTardiness that brings astronger relation between the order in a schedule and the sum of tardinesses. Consistency of theconstraint is achieved by a filtering algorithm. The algorithm builds a weighted network flowfrom the allowed time window of the tasks and their due date. The solution is implementedin a solver.

The experimental results show that the new algorithm applies stronger filtering, but its timecomplexity is too high to recommend it in practice. To conclude, several potential upgradesare proposed to reduce the execution time.

iv

Table des matières

Résumé iii

Abstract iv

Table des matières v

Liste des tableaux vii

Liste des figures viii

Remerciements ix

Introduction 1

I Notions préliminaires 3

1 La programmation par contraintes en ordonnancement 41.1 Problème combinatoire . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 41.2 Méthode de résolution . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 61.3 Ordonnancement . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 9

2 Optimisation 152.1 Réseaux de flot . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 152.2 Applications pour la contrainte AllDifferent . . . . . . . . . . . . . . . . 192.3 Applications pour la contrainte CostGCC . . . . . . . . . . . . . . . . . . 22

II Contributions 26

3 Contrainte DisjunctiveTardiness 273.1 Définition de la contrainte . . . . . . . . . . . . . . . . . . . . . . . . . . . . 273.2 Décomposition non satisfaisante . . . . . . . . . . . . . . . . . . . . . . . . . 273.3 Difficulté et popularité du problème . . . . . . . . . . . . . . . . . . . . . . 283.4 Relaxation . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 293.5 Filtrage avec l’approche CostGCC . . . . . . . . . . . . . . . . . . . . . . . 323.6 Compression du graphe . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 37

4 Expérimentations 43

v

4.1 Algorithmes comparés . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 434.2 Comparaison avec instances résolubles . . . . . . . . . . . . . . . . . . . . . 444.3 Comparaison avec instances de la littérature . . . . . . . . . . . . . . . . . . 474.4 Travaux futurs . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 49

Conclusion 53

A Glossaire 54A.1 Notations du mémoire en ordre d’occurrence et groupées par dépendance . . 54

Bibliographie 57

vi

Liste des tableaux

A.1 Notation du chapitre 1 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 54A.2 Notation du chapitre 1 (suite) . . . . . . . . . . . . . . . . . . . . . . . . . . . . 55A.3 Notation du chapitre 2 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 55A.4 Notation du chapitre 3 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 56A.5 Notation du chapitre 4 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 56

vii

Liste des figures

2.1 Flot valide initial dans un graphe . . . . . . . . . . . . . . . . . . . . . . . . . . 172.2 Graphe résiduel selon le flot initial . . . . . . . . . . . . . . . . . . . . . . . . . 172.3 Ajout d’un flot sur un chemin augmentant . . . . . . . . . . . . . . . . . . . . . 172.4 État des domaines dans l’exemple 1.3 . . . . . . . . . . . . . . . . . . . . . . . 192.5 Réseau de flot encodant l’état des domaines . . . . . . . . . . . . . . . . . . . . 202.6 Graphe résiduel après l’application de Ford et Fulkerson [9] . . . . . . . . . . . 212.7 Réseau encodant l’instance pour CostGCC . . . . . . . . . . . . . . . . . . . . 242.8 Flot optimal illustrant un support pour CostGCC . . . . . . . . . . . . . . . . 25

3.1 Filtrage avec le réseau d’ordonnancement avec retards . . . . . . . . . . . . . . 333.2 Graphe compressé pour l’exemple 3.3 avec seulement 3 nœuds de valeur . . . . 383.3 Graphe compressé pour l’exemple 3.1 avec au plus 3n− 1 intervalles . . . . . . 40

4.1 Nombre de retours sur trace de DisjunctiveTardiness par rapport à la dé-composition avec branchement en ordre lexicographique . . . . . . . . . . . . . 45

4.2 Proportion cumulée d’instances pour lesquelles le nombre de retours sur traceest compétitif à un facteur près - MDT exclu . . . . . . . . . . . . . . . . . . . 46

4.3 Proportion cumulée d’instances pour lesquelles le retard de la solution est com-pétitif à un facteur près - COS avec branchement 4.1 . . . . . . . . . . . . . . . 48

4.4 Proportion cumulée d’instances pour lesquelles le temps pour obtenir une solu-tion compétitive est court à un facteur près - COS avec branchement 4.1 . . . . 49

4.5 Flot optimal trivial . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 51

viii

Remerciements

Loin de moi l’idée d’être la personne la mieux placée, je me permets de témoigner de la géné-rosité incontestable de Claude-Guy Quimper. Générosité qui s’est manifestée sous toutes lesformes au cours de ma maîtrise. Claude-Guy m’a avant tout donné le goût pour la recherche etm’a confié un projet de son domaine qui lui tient à coeur. Il m’a ensuite fait une place dans sonlaboratoire et m’a entouré de collègues forts inspirants. Notamment, il m’a donné les moyensde m’investir à fond dans mon projet, privilège duquel je lui serai éternellement reconnaissant.Il m’a donné de précieux conseils dont les applications s’étendent aux péripéties du quotidien.Non exhaustivement, Claude-Guy s’est aussi montré généreux en écoute, en encadrement, enblagues et, surtout, en pistes de solution. En recherche, le nombre d’interrogations n’est pasborné par un polynôme. Heureusement, Claude-Guy est disponible en temps constant. Mercià toi Claude-Guy.

Je tiens tout autant à remercier Mel qui me soutient tous les jours. Elle est pour moi unesource d’énergie inépuisable qui m’aide à me dépasser. Elle est aussi un modèle d’excellenceen recherche que j’ai peine à suivre. Elle n’arrête jamais de me surprendre. À mon tour de lefaire : Mélissa, veux-tu m’épouser ?

Merci aussi à ma famille qui a su prendre soin de moi malgré la distance et à Nath qui est làdepuis le tout début de mon aventure à Québec.

Merci à Lewis de m’avoir poussé à faire des études supérieures. J’ai un dépassement de pileà me remémorer toutes les discussions passionnantes et tordantes que nous avons eu surl’informatique théorique et qu’il est difficile de placer en cette ère de web omniprésent.

Merci finalement au micro-ondes défectueux du Pouliot... Jamais je n’aurais pensé qu’un bidulede la sorte marque le début d’une boucle infinie de rassemblements d’amis autour d’une IPA.

ix

Introduction

La complexité des défis rencontrés dans l’industrie est croissante. La ruée sur l’automatisationdes processus d’affaires révèle constamment de nouveaux défis à relever. Qu’ils traitent deconfection d’horaire ou de planification de la production dans une usine, ces défis peuvent semanifester sous la forme de problèmes d’ordonnancement. Le cas échéant, le but est d’exé-cuter dans un ordre adéquat un ensemble de tâches régies par des contraintes temporelles.La communauté en optimisation combinatoire se penche quotidiennement sur ces problèmes.Plusieurs méthodes de résolution efficaces ont été développées. Une méthode prometteuse pourle domaine de l’ordonnancement est la programmation par contraintes.

La programmation par contraintes a déjà fait ses preuves pour trouver efficacement des so-lutions optimales à des problèmes d’ordonnancement dont l’objectif est simple tel que la mi-nimisation du temps de complétion de l’ordonnancement (makespan). En revanche, ce n’estpas le cas pour les problèmes d’optimisation où l’objectif est plus complexe. La minimisationdu retard impliqué dans un ordonnancement de tâches est un objectif typique. Ce mémoiredécoule de travaux entamés pour pallier le manque en programmation par contraintes vis-à-vis la résolution de problèmes d’optimisation dans le domaine de l’ordonnancement avecminimisation des retards.

Un problème combinatoire est composé de variables et de contraintes à satisfaire. Pour unproblème d’optimisation, une fonction objectif est nécessaire pour quantifier la qualité d’unesolution. Cette fonction doit être minimisée ou maximisée. La programmation par contraintestire son efficacité de ses algorithmes de filtrage assurant la cohérence des contraintes tout aulong de la résolution. La stratégie utilisée pour résoudre un problème d’optimisation est avanttout de trouver une solution satisfaisante. La valeur objectif de cette solution sert de référencepour la suite. Le raisonnement se poursuit pour déterminer si la solution est optimale. Si leraisonnement mène à une solution dont la valeur objectif est meilleure, cette dernière devient lanouvelle référence. Le raisonnement se poursuit tant qu’il peut exister de meilleures solutions.

Prouver qu’une solution est optimale occupe une bonne proportion du temps de résolution.Par conséquent, pour éviter de chercher inutilement, la stratégie doit intégrer le calcul d’uneborne sur la valeur objectif. Une méthode courante consiste à extraire cette borne d’une solu-tion optimale pour une relaxation du problème original. Dans le contexte de l’ordonnancement

1

non préemptif, cela revient à déduire le retard minimal d’un ordonnancement préemptif sa-tisfaisant. Une contribution du mémoire est l’intégration à la programmation par contraintesde nouveaux raisonnements sur la relation entre l’ordre d’exécution de tâches et le retard en-gendré. La façon de procéder est de définir une nouvelle contrainte globale dont l’algorithmede filtrage applique ces raisonnements. Les travaux se concentrent sur le cas où les tâches nepeuvent pas se chevaucher dans le temps et où le retard impliqué par l’ordonnancement croitselon une fonction convexe.

Le mémoire est séparé en deux parties. La première partie présente les notions nécessairesà la compréhension de la contribution. D’abord, le premier chapitre donne une définitionmathématique d’un problème de satisfaction de contraintes et d’un problème d’optimisationsous contraintes. Ces définitions sont reprises pour introduire les problèmes d’ordonnancementavec ressources unaires. Une section décrit comment la programmation par contraintes peutservir à accélérer la recherche de solutions pour ce type de problème. Les algorithmes de filtrageassurant la cohérence de contraintes sont intrinsèques à cette technique. Différents algorithmesde filtrage spécialisés pour les problèmes d’ordonnancement sont décrits. Cet état de l’art sertde base pour la suite. Ensuite, le second chapitre présente les réseaux de flot comme unoutil efficace pour résoudre des problèmes d’optimisation fondamentaux. Deux applicationsdes réseaux de flots à la programmation par contraintes sont illustrées pour appuyer leurpertinence. Une qui demande de résoudre le problème du flot maximum et l’autre, le problèmedu flot maximum à coût minimum.

La deuxième partie englobe la contribution issue des travaux de recherche. Le chapitre 3 couvrela nouvelle contrainte comblant un manque en programmation par contraintes. Un algorithmede filtrage basé sur un réseau de flot pondéré est donné. La contrainte encode un problèmedifficile à résoudre. L’algorithme doit alors résoudre une variante relaxée du problème. Desajustements au réseau sont également nécessaires pour que l’algorithme s’exécute en tempspolynomial. Finalement, le chapitre 4 évalue la performance de la solution proposée. La forcedu filtrage de l’algorithme et son temps d’exécution sont deux métriques à considérer. Unediscussion accompagne les résultats et une réflexion sur des travaux futurs est exposée.

2

Première partie

Notions préliminaires

3

Chapitre 1

La programmation par contraintes enordonnancement

Plusieurs techniques existent pour résoudre les problèmes d’optimisation combinatoire. Lemémoire se concentre sur une en particulier, soit la programmation par contraintes. Ce chapitreintroduit les notions de base de cette technique. L’utilisation de contraintes génériques pourmodéliser les problèmes rend la méthode expressive. Il y a notamment des applications dansle domaine de l’ordonnancement. Pour illustrer ce fait, des contraintes pertinentes encodantdifférents problèmes d’ordonnancement sont présentées.

1.1 Problème combinatoire

Un problème combinatoire est un problème mathématique dont la recherche de solutionss’effectue dans un espace de recherche discret. Un problème d’optimisation combinatoire estun problème combinatoire auquel s’ajoute une fonction objectif qu’on cherche à minimiser oumaximiser. Cette fonction quantifie la qualité d’une solution.

Un exemple de problème d’optimisation combinatoire est celui de l’ordonnancement de la pro-duction dans une usine. Dans le carnet de commandes, l’usine a plusieurs produits à livrer.Elle doit attendre l’arrivée des matières premières avant de démarrer la fabrication d’un pro-duit. Elle doit terminer la fabrication avant une échéance prescrite. En aucun cas on ne peutse permettre de surcharger la ligne de production. Il faut donc étaler la production dans letemps. La livraison d’un produit au-delà de son échéance entraîne une pénalité proportionnelleau retard. Dans ce contexte, un critère d’optimisation est de minimiser les pénalités de retardpour l’ensemble de la production.

4

1.1.1 Définitions

Les problèmes d’optimisation combinatoire traités dans ce mémoire sont avant tout des pro-blèmes de satisfaction de contraintes et des problèmes d’optimisation sous contraintes.

Problème de satisfaction de contraintes

Un problème de satisfaction de contraintes (CSP) est composé de variables X1, . . . , Xn etde contraintes C1, . . . , Cm. Chaque variable Xi est associée à un domaine de valeurs que l’ondénote dom(Xi). Les valeurs des domaines peuvent être énumérées ou définies par un intervalle.Une variable doit éventuellement prendre une valeur de son domaine, ce qui consiste en sonaffectation. Une affectation regroupe des variables affectées avec leur valeur. Elle est partiellesi elle concerne un sous-ensemble des variables et complète si elle concerne toutes les variablesdu problème.

Une contrainte définit une relation sur un sous-ensemble de variables que l’on appelle sa portée.L’arité d’une contrainte est la cardinalité de sa portée. Une contrainte binaire est une contrainted’arité 2, une contrainte tertiaire d’arité 3 et ainsi de suite. Une contrainte est un ensemble detuples de même dimension que son arité. Une affection des variables satisfait une contrainte siles valeurs affectées aux variables de la portée forment un tuple appartenant à la contrainte.Une contrainte peut être définie en extension, qui est une énumération explicite des tuples, ouen compréhension, c’est-à-dire une expression mathématique qui définit l’appartenance d’untuple à une contrainte.

Exemple 1.1. Un exemple est la contrainte tertiaire Ou pour des variables booléennes.

Ou(A,B,C) = (f, f, f), (f, v, v), (v, f, v), (v, v, v) 〈définition en extension〉

= (A,B,C) | A ∨B ⇔ C 〈définition en compréhension〉

Parmi les huit affectations complètes possibles pour trois variables booléennes, la contrainteOu n’en admet que quatre.

La plupart du temps, un problème est modélisé avec plus d’une contrainte. Au final, il y a unesolution au problème s’il existe une affectation complète satisfaisant toutes les contraintes.

Problème d’optimisation sous contraintes

Un problème d’optimisation sous contraintes est un CSP auquel on greffe une fonction objectif.La fonction dépend des variables du problème. De ce fait, il convient souvent d’introduire unenouvelle variable dont le domaine est l’image de la fonction. Par la suite, il suffit de précisers’il faut minimiser ou maximiser cette variable.

5

1.1.2 Complexité de la résolution

Comme l’ordonnancement de la production dans une usine, de nombreux problèmes rencontrésen pratique sont classés comme NP-Complets. Le CSP SAT, premier problème reconnu NP-Complet, en est un bon exemple. Ce problème de décision demande de confirmer la satisfiabilitéd’une formule booléenne. Il n’y a pas, à ce jour, d’algorithme s’exécutant en temps polynomialconnu pour le résoudre. Par conséquent, bien des instances de CSPs ne sont pas résolues enun temps raisonnable. En revanche, il existe plusieurs techniques accélérant la recherche desolutions. La technique préconisée dans ce mémoire est la programmation par contraintes.

1.2 Méthode de résolution

Une méthode efficace pour résoudre les problèmes d’optimisation combinatoire est la program-mation par contraintes. Dans ce domaine, la communauté contribue de plusieurs manières. Unepartie travaille sur des modèles élégants pour représenter des problèmes de tous les jours alorsque d’autres élaborent de nouveaux algorithmes qui servent d’outils aux modélisateurs. Unetroisième partie développe des solveurs de contraintes qui se chargent d’interpréter les modèleset gèrent la recherche de solutions pour un problème ciblé.

1.2.1 Filtrage

En programmation par contraintes, des algorithmes de filtrage sont intégrés à chaque contrainted’un CSP. Ces algorithmes interagissent avec les variables de la portée en retirant de leur do-maine les valeurs empêchant de satisfaire la contrainte. À ce moment, il devient pertinentpour un état des domaines de fournir un indicateur de la satisfiabilité d’une contrainte. Pource faire, il faut introduire différents degrés de cohérence pour une contrainte. Un algorithmede filtrage est notamment caractérisé par le degré de cohérence qu’il applique sur les domainesdes variables touchées par sa contrainte. Pour démontrer une certaine cohérence, on chercheavant tout un support. Un support est une affectation des variables de la portée respectantles critères de son degré de cohérence correspondant. La cohérence de bornes et la cohérencede domaine sont deux indicateurs standards en programmation par contraintes.

Cohérence de domaine

La cohérence de domaine demande de s’assurer que toute valeur présente dans un domainene remet pas en question la satisfaction de la contrainte. Un support de domaine pour unecontrainte C est un tuple de C dont chaque valeur vi appartient au domaine de sa variablecorrespondante : vi ∈ dom(Xi). C est cohérente de domaine si chacune des valeurs dans ledomaine des variables est impliquée dans l’existence d’un support de domaine pour C.

6

Cohérence de bornes

La cohérence de bornes ne requiert que de s’attarder à la valeur minimale et la valeur maximalequ’une variable peut prendre. Elle est bien adaptée pour les variables dont le domaine estreprésenté par un intervalle. Un support d’intervalle pour une contrainte C est un tuple deC dont chaque valeur vi ∈ [min(dom(Xi)),max(dom(Xi))]. C est cohérente de bornes si pourchaque valeur min(dom(Xi)) et max(dom(Xi)), il existe un support d’intervalles pour C.

Exemple 1.2. Soit la contrainte arithmétique Double(X,Y ) = (X,Y ) | Y = 2X avecdom(X) = 1, 2 et dom(Y ) = 1, 2, 3, 4. Un algorithme de filtrage appliquant la cohérencede bornes ne filtrera que la valeur 1 de dom(Y ). En revanche, un autre algorithme appliquantla cohérence de domaine filtrera les valeurs 1 et 3. Cet exemple illustre d’ailleurs qu’appliquerla cohérence de domaine assure également la cohérence de bornes.

Dépendamment du problème encodé par la contrainte, il est plus dur de concevoir un algo-rithme appliquant la cohérence de domaine. Un algorithme appliquant la cohérence de domainea souvent un temps d’exécution plus lent qu’un algorithme appliquant la cohérence de bornes.En revanche, appliquer la cohérence de domaine filtre davantage l’espace de recherche. Il y adonc un compromis à faire entre la quantité de filtrage souhaitée et le temps pour accomplirce filtrage.

Propagation

Un changement de l’état des domaines engendré par un algorithme de filtrage remet en ques-tion le degré de cohérence du reste des contraintes. Pour revenir au même niveau de cohérence,il faut propager le changement. Cette propagation de contraintes consiste à appeler les algo-rithmes qui filtrent les domaines des variables touchées par le changement. L’opération estrépétée jusqu’à ce que l’état des domaines demeure inchangé. Autrement dit, lorsque toutesles contraintes sont cohérentes.

1.2.2 Modélisation

La définition d’un CSP est reprise pour effectuer la modélisation. Le problème est modélisé endéterminant les variables, leur domaine et les contraintes qui lui donnent une représentationmathématique.

Choix des contraintes

Dépendamment de sa complexité, il existe souvent plus d’un modèle pour un même problème.Cependant, pour qu’un modèle soit le moindrement efficace, il doit contenir un nombre decontraintes borné par un polynôme du nombre de variables. Ce nombre dépend notammentdu choix des contraintes.

7

Un choix judicieux de contraintes augmente les performances au moment de la résolution dumodèle. Il arrive qu’un problème complexe puisse se décomposer en sous-problèmes. Dans cecas, pour faciliter la modélisation, des contraintes globales sont favorisées. Ces contraintes,élaborées pour des sous-problèmes particuliers, unissent plusieurs contraintes primitives et sefaisant encadrent mieux la résolution. Effectivement, en tenant compte de l’interaction entreplusieurs contraintes, il est possible d’intégrer de meilleurs algorithmes de filtrage à travers leprocessus de résolution. De par leur rôle, la plupart sont d’arité arbitraire. En revanche, tousles solveurs n’incluent pas l’ensemble des contraintes globales dans leur catalogue. Au final, lemodélisateur doit en tenir compte pour que le modèle conçu soit traitable.

Exemple 1.3. Un sous-problème fondamental est celui exigeant que certaines variables en-tières prennent une valeur différente. C’est le cas lorsque l’on modélise un problème d’ordon-nancement où les tâches, dont les temps de début sont encodés par des variables, ne peuventdémarrer au même moment. Soit ce problème contraignant les variables X1, X2 et X3, unemodélisation triviale incorporerait les contraintes d’inégalité binaires X1 6= X2, X2 6= X3 etX3 6= X1. Cependant, en programmation par contraintes, il se trouve qu’une contrainte glo-bale dénommée AllDifferent est spécifiquement conçue pour ce problème. Cette contrainten-aire encode le problème en agissant sur l’ensemble des variables impliquées. Un modèle alter-natif peut simplement incorporer la contrainte AllDifferent(X1, X2, X3). Dans un contexteoù dom(X1) = dom(X2) = 1, 2 et dom(X3) = 2, 3, une remarque pertinente est que lesvaleurs 1 et 2 peuvent exclusivement être assignées aux variables X1 et X2. Par déduction, lavaleur 2 peut être filtrée de dom(X3). C’est le raisonnement global que AllDifferent fait.Ce n’est pas le cas en se penchant individuellement sur la satisfiabilité de chaque contrainted’inégalité. Ainsi, lorsque le problème est formulé à l’aide de contraintes globales, l’espace derecherche est réduit davantage et l’on économise en temps de calcul.

1.2.3 Recherche de solutions

La recherche de solutions est gérée par un solveur de contraintes. C’est un logiciel qui aide àdécrire des problèmes combinatoires et les résout avec diverses techniques de programmationpar contraintes. Il permet d’introduire plusieurs types de variables (entier, booléen, ensembleou réel). Chaque solveur inclut son propre catalogue de contraintes applicables aux variables. Ilest également possible de configurer la recherche, c’est-à-dire d’indiquer avec des heuristiquesles régions de l’espace de recherche susceptibles de contenir des solutions.

L’espace de recherche est fondamentalement une arborescence. Chaque nœud est lié à uneaffectation partielle et chaque feuille à une affectation complète. Le solveur débute la rechercheà la racine où l’affectation est vide. Le but est de trouver des affectations complètes qui satisfonttoutes les contraintes du modèle. L’exploration d’un nœud enfant (ou branchement) consisteen l’affectation d’une variable supplémentaire. Cette affectation implique un changement del’état des domaines et déclenche par conséquent une propagation de contraintes. Avec ce

8

mécanisme, le solveur s’assure d’explorer des régions de l’espace de recherche cohérentes avecles contraintes. De plus, les feuilles auxquelles il aboutit sont nécessairement des solutions auproblème.

Il arrive que la propagation de contraintes vide complètement le domaine d’une variable. Àce moment, les domaines sont dans un état tel qu’il est impossible de satisfaire la contrainteresponsable de l’événement. Cette impasse est causée par la dernière variable affectée. Leretour à un état satisfaisant se fait en remontant l’arborescence et en choisissant une autreaffectation. Cette technique s’agit d’un retour sur trace. Le solveur en profite également pourfiltrer la valeur responsable de l’impasse. À la fin de la recherche, si le solveur n’a pas exploréde feuille, alors il n’y a pas de solution au problème.

1.3 Ordonnancement

Depuis les dernières années, le domaine de l’ordonnancement gagne en popularité chez lacommunauté en programmation par contraintes. De nombreux solveurs incluent maintenantdans leur catalogue des contraintes globales spécifiquement conçues pour la résolution deproblèmes d’ordonnancement.

1.3.1 Définitions

Un problème d’ordonnancement demande de régir l’ordre d’exécution de n tâches. Il convientde référer aux tâches avec un ensemble ordonné I = 1, . . . , n. Le problème présenté àla section 1.1 est un exemple classique de problème d’ordonnancement. Dans le contexte dumémoire, les tâches s’exécutent toutes sur la même ressource. Par conséquent, elles ne peuventpas se chevaucher dans le temps. Les instances de ces problèmes sont dites disjonctives. Aussi,il n’est souvent pas permis d’arrêter l’exécution d’une tâche une fois qu’elle est débutée. Il estalors question d’ordonnancement non préemptif. Sans perte de généralité, une tâche renfermeles caractéristiques suivantes :

— S ; la variable indiquant à quel instant la tâche débute (starting time)

— p ; son temps de traitement (processing time)

— est = min(dom(S)) ; le plus petit instant auquel la tâche peut débuter (earliest startingtime)

— d ; l’échéance préférable à laquelle la tâche devrait être terminée (due time)

— lct = max(dom(S)) + p ; l’instant limite auquel la tâche doit être terminée (latest com-pletion time)

Une solution au problème consiste à trouver une valeur satisfaisante pour chaque temps dedébut Si. Les tâches ne peuvent pas débuter à n’importe quel moment. Soit I l’ensemblede toutes les tâches d’un problème, un ordonnancement séquentiel proposé doit respecter les

9

fenêtres d’exécution. Autrement dit, pour chaque tâche i, Si ∈ [est i, lct i − pi]. Il y a aussi lescaractéristiques relatives à un ensemble de tâches. Soit un ensemble de tâches Ω ⊆ I, alors :

— est Ω = mini∈Ω est i

— lct Ω = maxi∈Ω lct i

— h = lct I − est I ; la taille de la fenêtre d’exécution globale ou l’horizon

— pΩ =∑

i∈Ω pi

En optimisation, chaque tâche se terminant après son échéance d implique un retard. Dans cecontexte, obtenir un ordonnancement valide n’est pas suffisant. Généralement, il est préférablequ’il n’y ait aucun retard. Cependant, ce n’est pas toujours possible. Par conséquent, pourindiquer une préférence sur la solution, le problème vient avec une fonction objectif qu’ilfaut optimiser. Pour éviter les retards, ces fonctions sont conçues pour exiger que les tâches seterminent le plus tôt possible. De plus, elles sont souvent convexes. Effectivement, les fonctionsconvexes ont des propriétés qui peuvent être exploitées et suffisent pour exprimer la plupartdes problèmes concrets [25]. En ordonnancement, minimiser le makespan ou le retard pondérésont des fonctions objectifs notamment pertinentes.

Minimisation du makespan

Pour un ensemble I de tâches à ordonnancer, minimiser le makespan, noté Cmax, revientsimplement a retenir les solutions valides dont l’ensemble des tâches se termine le plus tôtpossible. Soit Ci = Si + pi le temps de complétion d’une tâche i, Cmax = maxi∈I Ci estl’instant auquel toutes les tâches de l’ensemble sont terminées. Il faut donc minimiser Cmax.Il s’agit d’une stratégie globale visant à diminuer l’impact négatif des retards. Il n’est pasnécessaire de définir une échéance particulière pour chaque tâche. L’idée est simplement devouloir terminer au plus vite. L’avantage du makespan est qu’il s’agit d’une métrique simplequi est facile à modéliser et parfois à optimiser. Cependant, cette métrique a pour désavantagede ne pas exécuter au plus tôt les tâches du problème, si l’une d’entre elles est condamnée às’exécuter tardivement. Ainsi, seule la tâche la plus tardive est exécutée au plus tôt.

Minimisation du retard pondéré

Dans un contexte où l’exécution d’une tâche engendre un coût proportionnel à son retard, unepréférence serait de vouloir minimiser le retard pondéré. Le retard d’une tâche i, noté Ti, estla quantité de temps entre son échéance et son temps de complétion : Ti = max(0, Ci − di).Pour pondérer le retard, il faut introduire un poids wi pour chaque tâche. Le coût associé àl’ordonnancement d’une tâche i est donc wi · Ti. Le retard pondéré d’un ensemble de tâchesest défini par Tw,I =

∑i∈I(wi · Ti). Ainsi, minimiser le retard pondéré demande de ne retenir

que les solutions dont la somme des coûts est minimale.

10

1.3.2 Contraintes

Les contraintes suivantes sont utiles pour modéliser les problèmes d’ordonnancement. La listeest non exhaustive. Elle traite notamment des contraintes pertinentes dans le contexte dumémoire.

AllDifferent

Cette contrainte assure que chaque variable de sa portée prenne une valeur différente. Elle aété introduite par Régin [26].

AllDifferent([X1, . . . , Xn]) = (x1, . . . , xn) | xi 6= xj ∀ i 6= j (1.1)

Elle est fondamentale dans le domaine. Elle apparaît naturellement dans les problèmes impli-quant des permutations selon van Hoeve [14]. Il existe un algorithme en temps linéaire pourla cohérence de bornes. Cependant, López-Ortiz et collab. [19] précisent que leur version enO(n log n) est plus performante en pratique. De plus, Régin [26] donne un algorithme pour lacohérence de domaine en temps O(n2d2) tel que d la taille du plus grand domaine.

Par déduction, AllDifferent s’avère utile pour les problèmes d’ordonnancement. Particu-lièrement, si toutes les tâches ont un temps de traitement unitaire, il suffit d’encoder le tempsauquel s’exécute une tâche par une variable Xi de la portée de AllDifferent. De cettemanière, un support pour la contrainte représente directement un ordonnancement valide.

Global Cardinality Constraint (GCC)

Il s’agit d’une autre contrainte plus générale. Dans ce cas-ci, le nombre de fois qu’une valeurdoit être assignée à une variable est prescrit par un intervalle [l, u]. Cette borne est spécifiéepour des valeurs arbitraires. Dans la définition suivante, #(v, τ) représente le nombre de foisque la valeur v se retrouve dans un tuple τ .

GCC([X1, . . . , Xn], [v1, . . . , vd], [l1, . . . , ld], [u1, . . . , ud])

= (x1, . . . , xn) | 1 ≤ i ≤ d,∀ vi : li ≤ #(vi, (x1, . . . , xn)) ≤ ui (1.2)

Dans un contexte d’ordonnancement, avec l’intervalle [l, u], il y a là une notion de ressourcedisponible à chaque instant pertinent. GCC généralise la contrainte AllDifferent si l’in-tervalle est [0, 1] pour toutes les valeurs. D’ailleurs, Régin [23] l’introduit quelque temps aprèsAllDifferent. Il fournit un algorithme qui applique la cohérence de domaine en tempsO(n2d). Un peu plus tard, Quimper et collab. [22] donnent un algorithme plus efficace pourla même cohérence en temps O(n1.5d) et un algorithme en temps linéaire pour la cohérencede bornes [21].

11

CostGCC

CostGCC est une extension de GCC une fois de plus amenée par Régin [24]. Dans ce contexte,chaque affectation implique un coût. Le coût est donné par la fonction cost. cost(X,x) indiquele coût engendré par l’affectation d’une valeur x à la variable X. Le coût peut être un entierarbitraire. Pour que la contrainte soit satisfaite, la GCC qu’elle encode doit être satisfaite. Deplus, il ne faut pas que la somme des coûts dépasse un certain seuil variable H. Ci-bas, v, l etu sont des vecteurs de dimension d.

CostGCC([X1, . . . , Xn], v, l, u, cost, H)

= GCC([X1, . . . , Xn], v, l, u) ∩ (x1, . . . , xn) |n∑i=1

cost(Xi, xi) ≤ H (1.3)

Pour appliquer la cohérence de domaine, l’algorithme de Régin [24] utilise un algorithme deplus court chemin qui dépend de la taille d’un graphe construit à partir de l’instance. SoitW une borne supérieure pour la fonction cost et P (n, d,W ) le temps requis pour appliquerl’algorithme de plus court chemin, une variante notable de l’algorithme de Régin [24] s’exécuteen temps O(nP (n, d,W )).

Disjunctive

Cette contrainte est spécialisée pour assurer que des tâches de temps de traitement arbitrairesne s’exécutent pas en même temps. De plus, il est exigé que la solution soit non préemptive.Pour n tâches, il est désiré que les temps auxquels débutent les tâches soient représentés parles variables S1, . . . , Sn. Pour cette version de la contrainte, les temps de traitement p1, . . . , pn

sont constants.

Disjunctive([S1, . . . , Sn], [p1, . . . , pn])

= (s1, . . . , sn) | si + pi ≤ sj ∨ sj + pj ≤ si ∀ i 6= j (1.4)

Carlier [4] est le premier à en faire mention dans la littérature. Jusqu’à maintenant, il s’agitde la contrainte la plus notoire pour modéliser une grande partie, si ce n’est pas la totalité,des problèmes d’ordonnancement considérés dans ce mémoire. Elle généralise d’ailleurs lacontrainte AllDifferent si tous les pi sont unitaires.

Complexité pour appliquer la cohérence de bornes

L’expressivité de la contrainte permet d’encoder un problème d’ordonnancement à elle seule.Cependant, une faiblesse réside dans la faisabilité d’appliquer un certain degré de cohérence,et ce, en un temps raisonnable. Effectivement, le problème de déterminer s’il existe un or-donnancement qui satisfait Disjunctive est NP-Complet. Il s’agit du problème SS1 traitépar Garey et Johnson [10]. Or, trouver un support d’intervalle pour appliquer la cohérence de

12

bornes demande de résoudre le problème de recherche correspondant, ce qui est NP-Difficile.Donc, pour décrire le filtrage envisageable, la communauté s’est résorbée à définir des règlesde filtrage relaxées plus spécifiques à l’ordonnancement.

Règle du time-tabling Cette règle nécessite de raisonner sur la partie fixe des tâches. Lepremier algorithme de filtrage est donné par Le Pape [18]. Pour une tâche i, si lct i − est i <

2pi, soit lorsque dom(Si) est suffisamment petit, il est possible d’affirmer que la tâche doives’exécuter dans l’intervalle [lct i − pi, est i + pi). Cette affirmation implique un filtrage sur lafenêtre d’exécution d’une autre tâche j qui s’exécuterait à travers cet intervalle.

lct i − est i < 2pi ∧ lct i − est j < pi + pj ⇒ est ′j = max(est j , est i + pi)

〈définition du time-tabling〉 (1.5)

Ci-haut, est ′j est la nouvelle borne déduite. La propriété de symétrie du problème permetégalement de définir une version de la règle filtrant le lct . L’algorithme le plus rapide appliquela règle en temps linéaire [8].

Règle du edge-finding Cette règle demande de faire des déductions sur l’ordre d’exécutiondes tâches. Carlier et Pinson [5] sont les premiers à fournir un algorithme de filtrage. Soit Ω unsous-ensemble des tâches et une tâche i /∈ Ω, s’il n’est pas possible d’exécuter la tâche i dansla fenêtre d’exécution [est Ω, lct Ω] sans causer de débordement, alors la tâche i doit commenceraprès l’ensemble des tâches dans Ω.

est Ω∪i + pΩ∪i > lct Ω ⇒ est ′i = max(est i,maxΘ⊆Ω

(est Θ + pΘ))

〈définition du edge-finding〉 (1.6)

Pour savoir s’il y a débordement, il faut déterminer le temps de complétion minimal d’unensemble de tâches. maxΘ⊆Ω(est Θ +pΘ) est une borne adéquate pour ce temps de complétion.Comme le time-tabling , il existe une version de la règle pour filtrer le lct. Pour n tâches, Vilím[28] donne un algorithme considérant tous les sous-ensembles Θ pertinents en temps O(n log n).

Règle de l’overload checking Cette règle valide la satisfiabilité de la contrainte Dis-

junctive. Elle est intrinsèque au filtrage amené par la règle du edge-finding . Soit Ω unsous-ensemble des tâches, si le temps de traitement des tâches est plus grand que la taille dela fenêtre d’exécution admissible, alors les tâches débordent et il n’y a pas de solution selonl’état des domaines.

estΩ + pΩ > lct Ω ⇒ incohérence 〈définition de l’overload checking〉 (1.7)

Comme pour la règle du time-tabling , Fahimi et Quimper [8] donne un algorithme en tempslinéaire. Puisque la règle du edge-finding s’exécute à peine plus lentement que l’overload che-cking (O(n log n) plutôt que O(n)) et qu’il domine l’overload checking , en pratique, on favorisegénéralement l’edge-finding .

13

StockingCost

Houndji et collab. [16] ont spécifiquement conçu la contrainte StockingCost pour modéliserdes problèmes de planification de production en usine. Concrètement, StockingCost encoden commandes à produire sur une machine. Toutes les commandes ont un temps de traitementunitaire. La machine ne peut pas produire plus de c commandes à la fois. Contrairement à lacontrainte Disjunctive, il est permis d’exécuter des tâches en parallèle tant que la ressource lepermet. Chaque commande i doit être traitée avant une date de livraison di. Si une commandeest traitée à un instant xi ≤ di, il y a un coût d’entreposage di−xi qui lui est associé. CommeCostGCC, il ne faut pas que la somme des coûts dépasse un certain seuil variable H.

StockingCost([X1, . . . , Xn], [d1, . . . , dn], H, c)

= (x1, . . . , xn) | ∀xi : #(xi, (x1, . . . , xn)) ≤ c, xi ≤ di,n∑j=1

(dj − xj) ≤ H (1.8)

CostGCC est une généralisation de StockingCost si l’intervalle est [0, c] pour l’ensembledes valeurs et que la fonction cost encode le coût d’entreposage. Dans ce cas, cost(Xi, xi) =

cost(di, xi) = di − xi. Aussi, avec une ressource unaire (c = 1), StockingCost peut êtrevue comme une extension de AllDifferent à laquelle on ajoute la notion de coût lié à uneaffectation. Elle est donc une meilleure alternative aux modèles qui comportent une AllDif-

ferent et une contrainte d’inégalité agissant sur les mêmes variables. L’algorithme de filtragede Houndji et collab. [16] applique la cohérence de bornes en temps linéaire.

Cette contrainte encode le problème où l’on cherche à minimiser les coûts d’entreposage descommandes produites avant leur livraison. Cet objectif est symétrique à celui de minimiser leretard pondéré dont la pondération est neutre pour toutes les commandes. StockingCost

se prête donc bien aux problèmes d’ordonnancement lorsque les temps de traitement sontunitaires.

14

Chapitre 2

Optimisation

Une tâche importante d’un algorithme de filtrage appliquant une cohérence spécifique est detrouver un support pour la contrainte visée. Même si la contrainte n’en a pas l’aspect en soi, larecherche du support se réduit parfois à un problème d’optimisation. Plusieurs problèmes desatisfaction et d’optimisation associés à une contrainte globale peuvent se modéliser à l’aided’une structure abstraite appelée réseau de flot. Ce chapitre est spécifiquement dédié à cettestructure. Les fondements y sont présentés ainsi que les applications sur les contraintes globalesvues jusqu’à maintenant.

2.1 Réseaux de flot

Les réseaux de flot sont des graphes spécialisés. Ils sont couramment utilisés pour représenterdivers problèmes d’optimisation. Dans le cas de certaines contraintes en ordonnancement, larecherche d’un support passe par la résolution du problème du flot maximum dans un réseaude flot. De plus, lorsque la contrainte encode un coût lié à une solution, il faut résoudre leproblème plus général, soit le problème du flot maximum à coût minimum.

2.1.1 Définition

Les réseaux de flot sont des graphes orientés (N,A) dont chaque arête (u, v) ∈ A admet lacirculation d’un flot f quantifié. La quantité nette de flot circulant entre deux nœuds u et vest désignée par f(u, v). Si f(v, u) = 0∀u, v ∈ N , alors le flot est nul. Pour chaque arête (u, v)

est défini un poids c(u, v) représentant sa capacité. La capacité indique la quantité maximalede flot qui peut circuler sur l’arête. La capacité est nécessairement positive. L’absence d’unearête dans le graphe implique que la capacité est nulle pour cette paire de nœuds disjoints.Aussi, deux nœuds sont désignés pour jouer un rôle particulier. Ils sont nommés la source etle puits. La source s du réseau ne peut qu’émaner du flot. Elle n’accepte pas de flot entrant.Le puits a quant à lui un rôle symétrique. Il n’accepte pas de flot sortant.

15

2.1.2 Validité du flot

Pour traiter des problèmes avec les réseaux de flots, il convient de s’intéresser à la notionde flot valide. Un flot valide respecte certaines contraintes. Ces contraintes permettent defaire le rapprochement entre le réseau de flot et le problème concret qu’il traite. D’abord,la quantité de flot sur une arête ne peut dépasser la capacité : f(u, v) ≤ c(u, v). Ensuite,une autre restriction est d’imposer une quantité nette au flot circulant entre les nœuds. Parconséquent, pour une quantité de flot entre deux nœuds, il y a une quantité égale à l’opposéde flot qui circule en direction inverse. Autrement dit, f(u, v) = −f(v, u). Par conséquent,il est à noter que si (u, v) ∈ A et (v, u) /∈ A, alors f(v, u) ≤ c(v, u) = 0 et f(u, v) ≥ 0.Finalement, il y a conservation du flot d’un nœud à l’autre. Cependant, pour admettre d’autresflots que le flot nul, cette contrainte ne s’applique pas à la source et au puits du réseau :∑

u∈N f(u, v) =∑

w∈N f(v, w) ∀ v ∈ N \ s, t.

Dans un flot valide f circule globalement une valeur de flot précise que l’on dénote |f |. Dansce cas, puisque l’ensemble du flot provient de la source et culmine vers le puits, la valeur|f | =

∑u∈N f(s, u) =

∑u∈N f(u, t).

2.1.3 Graphe résiduel

Pour un flot f dans un réseau (N,A), il existe un graphe résiduel (N,Af ). Une arête ap-partient au graphe résiduel (u, v) ∈ Af si et seulement si elle n’est pas saturée, soit lorsquef(u, v) < c(u, v). Soit cf (u, v) = c(u, v) − f(u, v) la capacité résiduelle, on a donc la relation(u, v) ∈ Af ⇔ cf (u, v) > 0. Une notion induite par la définition de la capacité résiduelleest la récupération de flot : si (u, v) ∈ A, (v, u) /∈ A et f(u, v) > 0, alors (v, u) ∈ Af , carcf (v, u) = c(v, u) − f(v, u) = 0 − (−f(u, v)) = f(u, v) > 0. Donc, même si l’arête (v, u)

n’appartient pas au graphe (N,A), elle peut se retrouver dans le graphe résiduel.

Le graphe résiduel est utile pour modifier un flot existant sans compromettre sa validité. Cetteopération se fait en choisissant un chemin composé d’un ensemble d’arêtes du graphe résidueldans lequel un flot additionnel peut être envoyé. Cette définition du chemin est suffisante dansla mesure où l’on ne traite pas de chemins passant plus d’une fois par une même arête. À cemoment, pour chaque arête (u, v) de ce chemin C, la valeur de f(u, v) est augmentée de k unitéspendant que celle de f(v, u) est diminuée de la même quantité telle que k ≤ min(u,v)∈C cf (u, v).

Pour conserver un flot valide, deux types de modifications sont admissibles. La première estl’ajout d’un flot à travers un cycle dans le graphe résiduel, c’est-à-dire un chemin qui débute etaboutit sur le même nœud. La valeur du flot |f | est alors inchangée. La deuxième modificationconsiste à envoyer un flot sur un chemin reliant la source et le puits. Cette modificationengendre un changement de la valeur du flot en fonction du sens du chemin. Un chemin estdénommé chemin augmentant s’il débute à la source et culmine au puits. L’envoi de k unitésde flot sur un chemin augmentant fait passer la valeur du flot à |f ′| = |f |+ k.

16

s

u

v

w

t

1/2

3/3

2/3

1/2

3/3

Figure 2.1 – Flot valide initial dans un graphe

s

u

v

w

t

1

1

3

2

1

1

1

3

Figure 2.2 – Graphe résiduel selon le flot initial

s

u

v

w

t

2

3

1

2

2

3

Figure 2.3 – Ajout d’un flot sur un chemin augmentant

Exemple 2.1. La figure 2.1 montre un graphe avec un flot initial f dont |f | = 1. La fractionsur une arête (u, v) désigne le flot circulant par rapport à la capacité : f(u,v)/c(u,v). La figure 2.2montre le graphe résiduel correspondant. Le poids sur une arête désigne la capacité résiduellecf (u, v). Ce graphe illustre mieux les modifications possibles. Effectivement, le graphe résiduelmet en évidence les arêtes dont la capacité n’est pas saturée. Une modification envisageableest de pousser un maximum de 1 unité de flot sur le chemin (s → u → v → t). La figure 2.3montre le graphe résiduel une fois la modification faite. Puisque la modification est appliquéesur un chemin augmentant, la valeur du flot est maintenant |f ′| = |f |+ 1 = 2.

2.1.4 Problème du flot maximum

Le problème du flot maximum consiste, pour un réseau de flot donné, à construire un flot validedont la valeur est maximale, noté fmax. Une propriété intéressante du flot maximum est qu’il

17

n’existe pas de chemin augmentant dans son graphe résiduel correspondant (Théorème 6.4 dansAhuja et collab. [1]). Plusieurs techniques différentes pour résoudre ce problème sont présentesdans la littérature. Un algorithme simple basé sur la recherche de chemins augmentant dansle graphe résiduel est l’algorithme de Ford et Fulkerson [9]. L’algorithme débute avec le flotnul. De façon itérative, l’algorithme trouve un chemin augmentant en performant une fouilledans le graphe résiduel. Tant qu’un tel chemin C existe, l’algorithme ajoute min(u,v)∈C cf (u, v)

unités de flot sur ce chemin. Comme les modifications ne s’appliquent que sur des cheminsaugmentant, le flot augmente à chaque itération. L’algorithme s’arrête lorsqu’il n’existe plusde chemin augmentant. Sans stratégie de fouille particulière, l’algorithme s’exécute en tempsO(|A| · |fmax|). D’autres algorithmes, basés sur la même idée, se démarquent en choisissantjudicieusement le chemin augmentant pour maximiser l’augmentation de la valeur du flot. C’estle cas de l’algorithme ShortestAugmentingPath de Ahuja et collab. [2] qui s’exécute entemps O(|A||N |2).

2.1.5 Problème du flot maximum à coût minimum

Parfois, un réseau de flot n’est pas suffisant pour encoder le problème. C’est le cas lorsqu’unesolution au problème engendre un coût et qu’on ne veut pas que ce coût dépasse un certainseuil. Pour modéliser les coûts, une avenue est d’ajouter pour chaque arête (u, v) un poidsw(u, v) et de définir un coût cost(u, v) = w(u, v) · f(u, v) engendré par la circulation d’unequantité de flot. Aussi, pour demeurer cohérent avec la notion de flot net, w(u, v) = −w(v, u).Le poids w est dénommé le coût résiduel. Le coût d’un flot cost(f) correspond à la somme descoûts de chaque arête. Le problème du flot maximum à coût minimum consiste à construire unflot valide dont la valeur est maximale et dont le coût engendré par le flot est minimal. C’estle problème que Régin [24] doit résoudre pour trouver un support de domaine à la contrainteCostGCC.

De nombreuses stratégies existent pour résoudre le problème. Klein [17] en fournit une per-tinente dénommée CycleCancelingAlgorithm qui procède en deux étapes. L’algorithmerésout d’abord le problème du flot maximum sans tenir compte des coûts. Il procède ensuiteà la modification du flot en un flot au coût optimal pour vérifier que la solution ne dépassepas le seuil prescrit. Pour ce faire, il procède à une fouille pour trouver des cycles ayant uncoût négatif et pousse une quantité maximale de flot sur ces cycles. La modification engendrel’addition d’un coût négatif au coût total. Pour chaque cycle C détecté, le coût diminue de(min(u,v)∈C cf (u, v)

)·∑

(u,v)∈C w(u, v). Lorsqu’il n’y a plus de cycle de coût négatif, l’algo-rithme s’arrête et le flot est optimal. L’algorithme s’exécute en temps O(|A|cu) tel que c etu sont respectivement le coût maximal et la capacité maximale d’une arête dans le réseau.Un avantage particulier de cette approche est que pour trouver un support à la contrainteCostGCC, l’algorithme échoue rapidement s’il n’y pas d’affectation respectant la contrainteGCC correspondante.

18

2.2 Applications pour la contrainte AllDifferent

Une application pertinente des réseaux de flot est la recherche d’un support de domaine pourla contrainte AllDifferent. Cette recherche peut se réduire au problème du flot maximum.L’idée est que le réseau encode l’état des domaines et qu’un flot maximum pour ce réseauencode un support pour la contrainte. Il s’agit d’une partie du raisonnement de Régin [23] quidonne un algorithme appliquant la cohérence de domaine pour AllDifferent.

2.2.1 Réduction au problème du flot maximum

La première étape de réduction consiste à représenter l’état des domaines dans un graphebiparti. Un graphe est biparti s’il est possible d’obtenir deux partitions de ses sommets tellesqu’aucune arête ne relie deux nœuds d’une même partition. Une partition regroupe les variablesX = X1, . . . , Xn et l’autre les valeurs possibles V =

⋃ni=1 dom(Xi). Dans ce graphe, une arête

sert à indiquer qu’une valeur est dans le domaine d’une variable : (Xi, v) ∈ A∀ v ∈ dom(Xi).

Ensuite, le graphe est transformé en réseau de flot. Il faut ajouter une source s reliée auxvariables par les arêtes (s,Xi) et un puits t relié aux valeurs par des arêtes (v, t). La directiondes arêtes va de la source vers le puits. Finalement, dans le réseau, il est désiré qu’un flotpassant par une variable indique qu’elle a une seule affectation. Aussi, un flot passant par unevaleur indique qu’elle est affectée à une seule variable. Pour satisfaire ces critères, il suffit defixer la capacité des arêtes à 1.

X2

X1

X3

1

2

3

Figure 2.4 – État des domaines dans l’exemple 1.3

Exemple 2.2. Le graphe biparti de la figure 2.4 représente l’état des domaines dans l’exemple1.3. La partition de gauche regroupe les variables de la portée et celle de droite les valeurspossibles.

19

s X2

X1

X3

1

2

3

t

1

1

1

1

1

1

1

1

1

1

1

1

Figure 2.5 – Réseau de flot encodant l’état des domaines

La figure 2.5 montre le réseau de flot construit à partir du graphe précédent. Le poids sur lesarêtes indique leur capacité.

L’application de l’algorithme de Ford et Fulkerson [9] dans le réseau résultant construit unflot maximum illustrant un support de domaine pour AllDifferent. Un flot maximal dontla valeur est inférieure à l’arité de la contrainte implique qu’il n’existe pas de support dedomaine pour la contrainte. Cette illustration est également pratique pour déduire tous lesautres supports de domaine pour la contrainte. Pour obtenir un support de domaine à partird’un autre, il suffit de pousser un flot non nul à travers un cycle dans le graphe résiduel.Puisque la modification touche un cycle, le flot est toujours maximum et le graphe résiduelillustre un nouveau support distinct.

2.2.2 Filtrage à l’aide du support

Dans certains cas, les raisonnements découlant de l’analyse d’un support pour une contrainteinduisent un filtrage appliquant la cohérence correspondante. Pour les problèmes modéliséspar des graphes, la détermination des composantes fortement connexes est un outil d’analyseutile. Un graphe dirigé est dit fortement connexe si pour chaque paire ordonnée de ses nœuds,il existe un chemin reliant ces nœuds. Une composante fortement connexe dans un graphe estun sous-graphe fortement connexe tel qu’il n’est pas possible de lui ajouter un nœud sans ledémunir de sa propriété de forte connexité. L’algorithme de Tarjan [27] est reconnu pour sonefficacité à déterminer les composantes fortement connexes dans un graphe dirigé. Il s’exécuteen temps O(|N |+ |A|).

Dans son raisonnement, Régin [26] démontre que les composantes fortement connexes per-mettent de déterminer si une affectation possible est cohérente de domaine. Il faut que, dans

20

le graphe résiduel, toutes les valeurs n’appartenant pas à la même composante fortementconnexe d’une variable soient retirées du domaine de cette dernière. Ce critère doit être validépour toutes les affectations possibles qui ne sont pas présentes dans le support trouvé. Suite àce filtrage, la contrainte AllDifferent est cohérente de domaine.

s X2

X1

X3

1

2

3

t

−1/0

−1/0

−1/0

−1/0

0/1

0/1

−1/0

0/1

−1/0

−1/0

−1/0

−1/0

Figure 2.6 – Graphe résiduel après l’application de Ford et Fulkerson [9]

Exemple 2.3. En appliquant l’algorithme de Ford et Fulkerson [9] sur le graphe de la figure2.5, on obtient le graphe résiduel à la figure 2.6. La fraction sur une arête (u, v) désigne le flotcirculant par rapport à la capacité : f(u,v)/c(u,v). Le graphe illustre le support de domaine X1 =

1, X2 = 2 et X3 = 3. Le partitionnement des nœuds selon leur appartenance aux composantesfortement connexes est s, X1, X2, 1, 2, X3, 3 et t. Pour atteindre la cohérence dedomaine, il faut retirer la valeur 2 du domaine de X3 puisque cet élément ne se retrouve pasdans la même composante fortement connexe. La valeur 3 demeure dans le domaine même sielle ne se retrouve pas dans la même composante fortement connexe puisqu’elle est utilisée parle support. Après l’exécution de l’algorithme de Régin [26], dom(X1) = dom(X2) = 1, 2 etdom(X3) = 3. Dans une solution, X3 doit nécessairement être affectée à la valeur 3. Cetteanalyse plus poussée est l’avantage concret de AllDifferent par rapport aux contraintesindividuelles mentionnées dans l’exemple 1.3.

L’idée derrière l’algorithme de Régin [26] est que si une variable Xi et une valeur v appar-tiennent à la même composante fortement connexe, alors il existe un cycle passant par Xi etv. Donc, en poussant une unité de flot sur le cycle, on obtient nécessairement un autre supportde domaine pour la contrainte AllDifferent dont la valeur vi assignée à Xi est égale à v.

21

2.3 Applications pour la contrainte CostGCC

Dans la même optique, un support de domaine pour la contrainte CostGCC peut êtreconstruit en réduisant le problème à celui du flot maximum à coût minimum. Pour ce faire,Régin [24] étend le raisonnement appliqué pour la contrainte AllDifferent. Pour ne s’at-tarder qu’aux applications en ordonnancement, cette section se limite au cas particulier où lenombre minimal de fois lv qu’une valeur v peut être assignée est 0, même si l’algorithme deRégin supporte le cas où lv est positive.

2.3.1 Réduction au problème du flot maximum à coût minimum

La réduction est basée sur celle décrite à la section 2.2.1 pour la recherche d’un support pourla contrainte AllDifferent. Une différence notable est que la source s est plutôt reliéeaux valeurs V, les variables X au puits t et une arête relie une valeur v à une variable X siv ∈ dom(X). Cette variante transposée est utile pour appliquer le filtrage défini par Régin [24].Une autre différence est la capacité des arêtes reliant s aux valeurs. En lien avec la définitionde CostGCC, pour chaque valeur vd contrainte à être assignée un nombre maximal de fois ud,la capacité sur l’arête correspondante est c(s, vd) = ud. Ainsi, une nouvelle notion introduiteest que la quantité de flot passant par une valeur indique le nombre de fois que celle-ci estassignée à une variable. Finalement, pour gérer les coûts définis par la fonction cost, le poidsd’une arête reliant une valeur v à une variable X est w(v,X) = cost(X, v). Le poids est nulpour le reste des arêtes du réseau.

Une fois le réseau construit, l’application de l’algorithme de Klein [17] annulant les cyclesnégatifs détermine un flot optimal. Pour que CostGCC soit satisfaite, il faut qu’un flot nonnul passe par toutes les variables de la portée. De plus, le coût du flot cost(f) doit être inférieurou égal au seuil H prescrit, c’est-à-dire cost(f) ≤ max (dom(H)). À ce moment, le flot illustreun support de domaine et il est possible de filtrer en conséquence.

2.3.2 Filtrage à l’aide du support

L’application de la cohérence de domaine pour la contrainte CostGCC peut être vue en deuxétapes [24]. La première étape applique la cohérence de domaine pour la contrainte GCC

correspondante. Le filtrage basé sur les composantes fortement connexes présenté pour lacontrainte AllDifferent est repris ici. Cette étape est requise pour s’assurer, pour chaqueaffectation possible non utilisée par le support, qu’il existe un cycle passant par l’affectation.

La seconde étape tient compte des coûts et du seuil prescrits. Le coût du flot optimal sertde borne inférieure pour le seuil H. Comme mentionné pour la contrainte AllDifferent,une arête (v,X) symbolise une affectation X = v à valider. De plus, pousser une unité deflot sur un cycle passant par l’arête (v,X) donne un support pour l’affectation X = v. Bienque ce test soit suffisant pour AllDifferent et GCC, ce n’est pas assuré pour CostGCC.

22

Effectivement, pousser une unité de flot sur un cycle engendre un coût rc qui vient s’ajouterpour donner le coût du nouveau du flot cost(f ′) = cost(f)+rc. Or, pour que le flot f ′ illustre unsupport incluant l’affectation à valider, il faut une fois de plus que cost(f ′) ≤ max(dom(H)).Pour démontrer l’existence de ce flot f ′, Régin [24] prescrit, à partir du flot optimal, qu’ilsuffit de pousser un flot sur un cycle engendrant le plus petit coût, soit le coût réduit. En effet,puisque f est optimal, il n’existe pas d’autre support avec un coût inférieur. Par conséquent,rc ≥ 0 et si cost(f ′) > max(dom(H)), il est certain qu’il n’existe pas de support incluantl’affectation testée X = v. C’est donc de là que vient la motivation de construire un flotoptimal.

Les cycles engendrant des coûts réduits, soit les cycles optimaux, peuvent être déterminés enutilisant un algorithme de plus court chemin selon les poids wi définis dans le graphe résiduel.L’utilisation d’un algorithme de plus court chemin est déterminante dans la complexité del’algorithme de filtrage. Pour cette raison, il est important de minimiser son nombre d’appels.Plusieurs algorithmes de plus court chemin calculent les plus courts chemins d’un nœud dedépart vers tous les autres nœuds du graphe. De ce fait, l’idée est de calculer, pour chaquearête (v,X) dans le graphe résiduel, le cycle optimal passant par cette arête. Soit les variablesX et les valeurs V, l’ensemble des cycles optimaux passant par les affectations à valider peutêtre calculé de deux façons :

1. Faire |X | appels à l’algorithme de plus court chemin avec chaque variable comme nœudde départ. Pour un cycle passant par (v,X), le coût réduit engendré est la somme descoûts résiduels d’un plus court chemin C = (X → . . . → v) ajouté au coût résiduel de(v,X). Autrement dit, rc =

∑(a,b)∈C w(a, b) + w(v,X).

2. Dans le graphe transposé, faire |V| appels à l’algorithme de plus court chemin avecchaque valeur comme nœud de départ. Le coût réduit engendré par un cycle optimalpassant par (X, v) est alors rc =

∑(a,b)∈C w(a, b) +w(X, v) tel que C = (v → . . .→ X)

est un plus court chemin dans le graphe transposé.

Les deux techniques ci-dessus permettent de calculer le coût du cycle optimal passant parn’importe quelle arête (v,X) avec un nombre limité d’appels à l’algorithme de chemin le pluscourt. En ordonnancement, il y a moins de variables que de valeurs. Il est donc préférabled’opter pour la première méthode.

La complexité de l’algorithme est dominée par les |X | appels à l’algorithme de plus court che-min. En utilisant l’algorithme de Bellman-Ford, la complexité en temps devient O(|X |2|V|2).D’ailleurs, en faisant circuler le flot des valeurs aux variables, Régin [24] évite d’avoir à trans-poser le réseau lors du filtrage. Ci-haut, v, l et u sont des vecteurs de taille d. Pour appliquerla cohérence de domaine, l’algorithme de Régin [24] utilise un algorithme de plus court cheminqui dépend de la taille de l’instance. Soit W le coût maximal retourné par cost et P (n, d,W )

le temps requis pour appliquer cet algorithme de plus court chemin, l’algorithme de Régin [24]est en temps O(nP (n, d,W )). Ainsi, l’algorithme de filtrage applique la cohérence de domaine

23

pour les variables Xi et la cohérence de borne pour le seuil H.

Exemple 2.4. Soit une instance pour la contrainte d’arité 3 définie comme suit :

— CostGCC([X1, X2, X3], v = [1, 2, 3], l = [0, 0, 0], u = [2, 1, 1], cost, H)

— dom(X1) = 1, 2 avec cost(X1, a) = a

— dom(X2) = 1, 2 avec cost(X2, a) = a

— dom(X3) = 2, 3 avec cost(X3, a) = a− 2

— dom(H) = [0, 3]

t X2

X1

X3

1

2

3

s

1

1

1

1(1)

1(1)

1(2)

1(2)

1(0)

1(1)

2

1

1

Figure 2.7 – Réseau encodant l’instance pour CostGCC

Le réseau de la figure 2.7 encode l’instance. La capacité et le coût de chaque arête sont indiquésselon le format capacité(coût).

Appliquer l’algorithme de Klein [17] construit un flot optimal dont le coût est de 2. Le flotest représenté dans le graphe résiduel de la figure 2.8. Le poids des arêtes illustre la capacitérésiduelle et le coût résiduel. Tel qu’expliqué, si le coût d’une arête est w, son coût résidueldemeure w dans le graphe résiduel, mais devient −w si cette arête est inversée. Le coût duflot cost(f) = 2 permet de fixer la borne inférieure de dom(H) à 2. Dans cet exemple, lescomposantes fortement connexes n’induisent pas de filtrage. Cependant, un filtrage selon lescoûts est possible.

Le support illustré par le flot est X1 = 1, X2 = 1, X3 = 2. Par conséquent, les affectationsà valider sont X1 = 2, X2 = 2 et X3 = 3. Un appel à l’algorithme de plus court chemin pourchaque variable révèle que le cycle optimal (X1 → 1 → s → 3 → X3 → 2 → X1) passant par(2, X1) engendre un coût réduit de −1 + 1 + 0 + 2 = 2. Puisque 2 + 2 > max(dom(H)) = 3, lavaleur 2 doit être filtrée de dom(X1). Un raisonnement similaire mène à la même conclusionpour la valeur 2 de dom(X2).

24

t X2

X1

X3

1

2

3

s

1

1

1

1(−1)

1(−1) 1(2)

1(2)

1(0)

1(1)

2

1

1

Figure 2.8 – Flot optimal illustrant un support pour CostGCC

25

Deuxième partie

Contributions

26

Chapitre 3

Contrainte DisjunctiveTardiness

Tel qu’exposé, un réseau de flot s’avère efficace pour la conception d’algorithmes de filtrageen ordonnancement. Dans ce chapitre, cet outil de modélisation est repris pour introduire unenouvelle contrainte globale. La contrainte, dénommée DisjunctiveTardiness, tient mieuxcompte, pour un ordonnancement donné, de l’interaction entre la contrainte Disjunctive etla minimisation du retard pondéré où la pondération du retard est la même pour l’ensemble destâches. Le problème encodé par la contrainte est énoncé. Une idée de sa difficulté est présentée.Un algorithme de filtrage pour la contrainte, basé sur une relaxation, est donné. Des liens sontfaits entre les notions amenées et l’état de l’art de l’ordonnancement. Finalement, pour rendrel’algorithme applicable en pratique, différentes variantes sont introduites.

3.1 Définition de la contrainte

DisjunctiveTardiness généralise la contrainte Disjunctive pour tenir compte des re-tards engendrés par l’ordonnancement de tâches. Le retard d’une tâche i est donné parTi = max(0, Ci − di) = max(0, Si + pi − di). Ainsi, soit l’ensemble de tâches I, pour quela contrainte soit satisfaite, il ne faut pas que la somme des retards TI ne dépasse un certainseuil T . TI est équivalent à la somme des retards pondérés où la pondération wi = 1 pourtoute tâche i dans I. Dans la définition, I est représenté par les trois vecteurs en paramètre.

DisjunctiveTardiness([S1, . . . , Sn], [p1, . . . , pn], [d1, . . . , dn], T )

= Disjunctive([S1, . . . , Sn], [p1, . . . , pn])∩(s1, . . . , sn) |n∑i=1

max(0, Si + pi − di) ≤ T

(3.1)

3.2 Décomposition non satisfaisante

En programmation par contraintes, l’alternative actuelle pour simuler DisjunctiveTardi-

ness est de la décomposer telle que définie. Il en résulte une contrainte Disjunctive en

27

conjonction avec une contrainte d’inégalité entre la somme des retards et le seuil T . Pour lacontrainte

∑ni=1 max(0, Si + pi − di) ≤ T , un algorithme de filtrage commun consiste à filtrer

la borne supérieure des temps de début. Pour ce faire, l’algorithme teste, pour chaque tâchei, si son retard maximal additionné au retard minimal des autres tâches I \ i ne dépassepas le seuil T . Si c’est le cas, la borne supérieure de Si est réduite à la plus grande valeurtelle que le test n’échoue plus. Puisque le retard est non décroissant, cet algorithme appliquela cohérence de domaine efficacement. Cependant, l’approche demeure non satisfaisante dansla mesure où il y a absence de raisonnement sur les interactions entre les contraintes. Pourla suite, cette approche naïve, notée NDT , servira de base pour évaluer la performance dessolutions proposées.

Exemple 3.1. Un exemple simple avec deux tâches permet d’illustrer une faiblesse de ladécomposition NDT par rapport à la contrainte DisjunctiveTardiness. Soit une instancepour la contrainte avec deux tâches comme suit :

DisjunctiveTardiness([Si avec dom(Si) = [0, 1], Sj avec dom(Sj) = [2, 3]],

[pi = 2, pj = 1],

[di = 0, dj = 3],

T avec dom(T ) = [0, 3])

En ce qui a trait aux contraintes, l’état des domaines est déjà cohérent avec la contrainteDisjunctive. C’est également le cas pour la contrainte d’inégalité, car :(max(dom(Si))+pi−di

)+(min(dom(Sj))+pj−dj

)= (1+2−0)+(2+1−3) ≤ 3 = max(dom(T ))(

min(dom(Si))+pi−di)+(max(dom(Sj))+pj−dj

)= (0+2−0)+(3+1−3) ≤ 3 = max(dom(T ))

Ainsi, dans cet exemple, les contraintes sont cohérentes et n’engendrent pas de filtrage. Il ya pourtant un filtrage envisageable. Selon l’état des domaines, il n’y a pas de support avecSi = 1 pour la contrainte DisjunctiveTardiness. Effectivement, si la tâche i commence autemps Si = 1, alors son retard est Ti = 3. Puisque le retard total TI = Ti + Tj ne peut paspas dépasser 3, la tâche j ne peut pas être en retard et elle doit donc commencer au tempsSj = 2. Cependant, cet ordonnancement viole la contrainte Disjunctive, car les deux tâchesse chevauchent au temps 2. La valeur 1 doit donc être filtrée du domaine de Si. Il s’agit làd’un type de raisonnement qu’une contrainte globale comme DisjunctiveTardiness apporteà un modèle.

3.3 Difficulté et popularité du problème

Le problème encodé par la contrainte DisjunctiveTardiness est un cas particulier du pro-blème demandant de trouver un ordonnancement séquentiel et non préemptif dont le retard

28

pondéré est minimal. Ce problème, noté PDT , est NP-Difficile dans le cas où la borne supé-rieure max(dom(T )) = ∞ puisqu’il nécessite de résoudre un sous-problème qui est lui aussiNP-Difficile, soit le problème encodé par la contrainte Disjunctive (voir section 1.3.2). Enpratique, cette situation est souhaitable lorsqu’on cherche à minimiser T et qu’il n’y a pasd’ordonnancement séquentiel connu pour l’instance à résoudre.

Bien souvent, la taille des instances en pratique est trop grande pour résoudre PDT à l’optimal.Par conséquent, la communauté en optimisation s’est beaucoup attardée au problème en déve-loppant des métaheuristiques comme des heuristiques de recherche locale [7]. Le problème estégalement difficile à solutionner avec des méthodes d’approximation. Effectivement, il n’existepas, à ce jour, d’algorithme en temps polynomial retournant une solution dont la valeur objec-tive n’est pas moins bonne à une constante près de celle optimale [6]. Aussi, pour la résolutiondu cas particulier où les tâches ont un temps de traitement arbitraire, il n’y a pas d’algorithmevorace ou d’algorithme qui s’exécute en temps polynomial connu [16]. Le problème n’est doncpas seulement difficile à résoudre avec des méthodes exactes, comme celles présentées dans lemémoire.

3.4 Relaxation

Un algorithme de filtrage adéquat doit s’exécuter en temps polynomial. Puisque construireun quelconque support pour la contrainte Disjunctive est NP-Difficile, une relaxation duproblème PDT est impérative. L’idée est de construire un ordonnancement qui respecte par-tiellement la contrainte. Ensuite, à partir de raisonnements découlant de cette solution, ilfaut chercher à appliquer un filtrage qui garantit de ne retirer aucune solution de l’espace derecherche. Nécessairement, à cause de la relaxation, il n’est pas possible de faire le filtragecomplet. Plus le choix de la relaxation est judicieux, moins le filtrage sera pénalisé.

3.4.1 Fiabilité et qualité de la borne

Dans le cas de PDT , dans la même optique que pour le support de CostGCC, il faut que lesupport relaxé construit optimise le retard. Soit une instance (I, T ) satisfiable pour Disjunc-

tiveTardiness, TImin le retard d’un support optimal selon l’état des domaines et TI′min leretard d’un support relaxé optimal pour le même état. Puisque l’ordonnancement est relaxé,alors TI′min ≤ TImin. Lors de la recherche, l’espace des solutions est davantage contraint pourchaque affectation Si = s du temps de début d’une tâche i. Cette exploration fait évoluerTI′min de façon non décroissante. Pour la même raison, c’est aussi le cas lorsqu’un algorithme

de filtrage teste un support pour Si = s. À tout moment, si TI′min > max(dom(T )), alors lacontrainte est assurément non satisfaite et il faut donc filtrer en conséquence. Au final, c’estle fait que TI′min soit une borne inférieure pour la valeur objective du problème original quipermet de faire un filtrage fiable.

29

Propriété 3.1. Pour que la borne TI′min soit fiable, il faut que TI′min ≤ TImin, même si lestâches ne sont pas interrompues dans la solution préemptive.

Une borne élevée contribue mieux à détecter les dépassements de coût et appliquer un filtrageconséquent. Ainsi, en réduisant davantage l’espace de recherche, l’optimum d’une solution peutêtre prouvé plus rapidement. Cependant, il y a souvent un compromis à faire entre la qualitéde la borne et le temps de calcul nécessaire pour l’obtenir. Ainsi, si la borne est lourde àcalculer, il faut s’assurer empiriquement que les gains en filtrage soient plus avantageux.

Propriété 3.2. Une borne TI′min de qualité indique une valeur se situant le plus près possiblede la valeur objective TImin du problème original.

3.4.2 Préemption

Une relaxation courante pour les problèmes d’ordonnancement est de permettre la préemptiontout en respectant la fenêtre d’exécution des tâches. Sur une ligne du temps, l’ordonnance-ment Ei d’une tâche i peut être décomposé en pi instants unitaires distincts auxquels la tâches’exécute. Ainsi, Ei = e | la tâche i s’exécute à l’instant e et |Ei| = pi. Une solution pré-emptive au problème permet de déduire une borne sur les temps de début et de complétiond’un ensemble de tâches [8]. Par exemple, si l’objectif est de minimiser le makespan Cmax, lemakespan obtenu dans une solution préemptive est toujours plus petit ou égal à celui obtenudans une solution non préemptive [8].

La préemption s’avère également utile pour calculer une borne sur le retard d’un ordonnan-cement non préemptif. La borne est déterminée à partir d’un ordonnancement préemptif oul’ordonnancement Ei est défini pour chaque tâche i. Cette méthode requiert nécessairementde décomposer le calcul du retard d’une tâche selon son ordonnancement préemptif pour ainsiobtenir son retard relaxé. Une décomposition naturelle est de considérer un retard w(e, i) pourchaque instant d’exécution e d’une tâche i. Dans ce contexte, chaque instant d’exécution e

peut être individuellement en retard en fonction de la tâche qui s’y exécute. Par souci defiabilité (propriété 3.1), la définition pour le retard non préemptif ne peut pas simplement êtrereprise : w(e, i) 6= max(0, Ci − di). Sinon, une tâche pourrait être considérée plus en retardqu’elle ne l’est vraiment et cette considération induirait un filtrage qui retire potentiellementdes solutions de l’espace de recherche. Une façon d’atteindre cet objectif serait d’exiger, pourchaque instant d’exécution e associée à une tâche i, que

∑e∈Ei

w(e, i) = T ′i ≤ Ti. De plus, ad-venant un ordonnancement non préemptif, soit une solution pour la contrainte Disjunctive,alors il faut que T ′i = Ti pour toute tâche i. Cette condition permet d’affirmer que l’on calculeune borne de qualité sur le retard (propriété 3.2).

Définition 3.1. Pour un ordonnancement préemptif Ei d’une tâche i, la définition rete-nue pour le calcul du retard relaxé de la tâche est la suivante : T ′i =

∑e∈Ei

w(e, i) =∑e∈Ei

⌈max(0,e+1−di)

pi

⌉.

30

Théorème 3.1. Si un ordonnancement préemptif Ei d’une tâche i est en fait non préemptif,c’est-à-dire si l’ensemble Ei est formé d’entiers consécutifs, alors le retard relaxé de la tâche,défini en 3.1, est égal à son retard.

T ′i =∑e∈Ei

⌈max(0, e+ 1− di)

pi

⌉= Ti

Démonstration. Soit la définition du retard d’une tâche Ti = max(0, Si + pi − di), sans pertede généralité, posons le temps d’exécution ej = Si + j pour j = 0..(pi − 1).

Cas 1 : Si + pi − di ≤ 0, alors la tâche n’est pas en retard, ej + 1− di ≤ 0 et w(i, ej) = 0∀ j.

Cas 2 : Si + pi − di > 0,alors il existe un plus petit indice k tel que 0 ≤ k < pi et ek + 1− di > 0.

Cas 2.1 : Si k = 0, alors toute la tâche est en retard, c’est-à-dire e0 ≥ di et Ti = Si + pi − di.

T ′i =∑e∈Ei

⌈max(0, e+ 1− di)

pi

⌉=

∑e∈Ei

⌈e+ 1− di

pi

⌉=

⌈Si + 0 + 1− di

pi

⌉+

⌈Si + 1 + 1− di

pi

⌉+ . . .+

⌈Si + pi − 1 + 1− di

pi

⌉=

⌈Si + 1− di

pi

⌉+

⌈Si + 2− di

pi

⌉+ . . .+

⌈Si + pi − di

pi

⌉=

⌈Ti − pi + 1

pi

⌉+

⌈Ti − pi + 2

pi

⌉+ . . .+

⌈Tipi

⌉〈Si + pi − di = Ti〉

= Ti 〈Propriété des fonctions plafonds, Graham et collab. [13]〉

Cas 2.2 : Si k > 0, alors une partie de la tâche est en retard et Ti = Si + pi − di = pi − k.

T ′i =k−1∑j=0

⌈max(0, ej + 1− di)

pi

⌉+

pi−1∑j=k

⌈max(0, ej + 1− di)

pi

⌉

= 0 +

⌈max(0, Si + k + 1− di)

pi

⌉+ . . .+

⌈max(0, Si + pi − 1 + 1− di)

pi

⌉=

⌈Si + k + 1− di

pi

⌉+ . . .+

⌈Si + pi − di

pi

⌉=

⌈1

pi

⌉+ . . .+

⌈pi − kpi

⌉〈k = di − Si〉

= pi − k 〈Propriété des fonctions plafonds, Graham et collab. [13]〉

= Ti

31

Corollaire 3.1. Soit T ′s le retard relaxé d’une solution préemptive s pour une instance duproblème PDT . Si s est en fait non préemptive, en reprenant la définition 3.1 pour le retardrelaxé d’une tâche, alors T ′s =

∑i∈I T

′i =

∑i∈I Ti = Ts, ce qui fait de Ts′ une borne de qualité.

Théorème 3.2. Soit sp une solution préemptive pour une instance du problème PDT et soits une solution non préemptive pour la même instance. En reprenant la définition 3.1 pour leretard relaxé d’une tâche, alors T ′sp ≤ Ts, ce qui fait de T ′sp une borne fiable.

Démonstration. Soit R l’ensemble des solutions préemptives pour une instance du problèmePDT , alors sp ∈ R. Soit Q l’ensemble des solutions non préemptives pour la même instance,alors s ∈ Q.

Par la définition de la préemption, Q ⊆ R. Or, par la définition de PDT , les solutions de Q etR sont respectivement optimales. Par conséquent, si sp /∈ Q, alors :

sp ∈ R \Q et T ′sp ≤ Ts

De plus, selon le théorème 3.1, si sp ∈ Q, alors :

T ′sp = Tsp = Ts

Cependant, ces instances de petite taille ne sont pas d’intérêt en pratique. Afin de mener cetteévaluation, il faut plutôt comparer avec des instances de la littérature qui tiennent compte desbesoins en pratique.

3.5 Filtrage avec l’approche CostGCC

En utilisant la définition 3.1 pour relaxer le problème, il devient envisageable de concevoir unalgorithme de filtrage pour la contrainte DisjunctiveTardiness qui tient compte du retard.À cause de la préemption, le problème PDT se traduit bien à celui encodé par CostGCC.

3.5.1 Représentation de l’état des domaines

Comme CostGCC, l’instance est représentée par un réseau de flot avec coûts, nommé leréseau d’ordonnancement avec retards. De façon similaire, la structure comporte une source set un puits t. Au puits t sont reliées chaque tâche i de I. À la source s sont reliés l’ensemble destemps d’exécution possibles selon l’état des domaines dom(Si) et les temps de traitement pi.Par exemple, si dom(Si) = 0, 1 et pi = 2, alors les temps d’exécution possibles pour la tâchei sont 0, 1, 2. Pour la représentation des domaines, il y a une arête (e, i) qui relie un tempsd’exécution e à une tâche i s’il est possible d’y exécuter cette même tâche. Autrement dit, pourchaque tâche i, on retrouve les arêtes (e, i) telles que min(dom(Si)) ≤ e < max(dom(Si)) +pi.

32

Dans un ordonnancement préemptif, une tâche i doit s’exécuter à pi instants. Il faut doncfixer les capacités des arêtes c(i, t) pour qu’elles correspondent au temps de traitement, c’est-à-dire c(i, t) = pi. La capacité des autres arêtes est fixée à 1. Un flot donné dans le réseaumodélise un ordonnancement. Un flot passant par l’arête (e, i) indique que la tâche i s’exécuteau temps e. Pour compléter la représentation, le coût du flot doit correspondre à la somme desretards relaxés des tâches ordonnancées. Pour ce faire, pour chaque arête reliant un instant eet une tâche i, un coût résiduel w(e, i) = w(e, i) tel que défini dans 3.1 est attribué à l’arête.Bien entendu, w(e, i) = −w(i, e) dans le graphe résiduel. Dans cette configuration, le réseaurésultant caractérise ainsi l’instance.

3.5.2 Algorithme de filtrage selon les retards

Le filtrage consiste à d’abord exécuter l’algorithme de Klein [17] pour déterminer un flotmaximum à coût minimum. Pour obtenir un ordonnancement valide, la valeur du flot maximumdoit être égale à la somme des pi. Le cas échéant, le coût du flot est alors une borne inférieurepour le seuil T . Nécessairement, pour demeurer cohérent, le coût ne doit pas dépasser le seuil.Pour filtrer les Si, on poursuit avec l’algorithme de filtrage de Régin [24] pour déterminer lesarêtes où il n’est pas envisageable d’envoyer un flot. Si un flot ne peut être envoyé sur une arête(e, i), alors la tâche i ne peut pas s’exécuter au temps e. Puisqu’au final il faut une solutionnon préemptive, la tâche ne peut pas débuter aux instants tel qu’elle s’exécuterait à l’instante. Dans ce cas, soit les instants d tels que e− pi < d ≤ e, les arêtes (d, i) doivent être retiréesdu réseau et les valeurs d retirées du domaine dom(Si). Pour la même raison, une valeur vdu domaine dom(Si) n’est cohérente que si la tâche i peut s’exécuter à tous les instants dansl’intervalle [v, v + pi).

t

i

j

0

1

2

3

s

2

1

1(−1)

1(−1)

1(2)

1(0)

1(1)

1

1

1

1

Figure 3.1 – Filtrage avec le réseau d’ordonnancement avec retards

Exemple 3.2. En reprenant l’exemple 3.1, on obtient le réseau de la figure 3.1. L’exécutionde l’algorithme de filtrage de Régin [24] résulte en un flot au coût de 2, ce qui permet de fixer le

33

domaine du seuil T à [2, 3]. Aussi, le flot ne peut pas circuler sur l’arête (2, i). Effectivement,pousser un flot sur le cycle (i→ 1→ s→ 3→ j → 2→ i) passant par l’arête (2, i) engendre uncoût réduit minimal de 2, ce qui est trop élevé pour que l’ordonnancement demeure cohérent :2 + 2 > 3. Ainsi, il faut retirer les arêtes (i, 1) et (i, 2) du réseau et filtrer la valeur 1 de Si. Àl’aide du flot, l’algorithme capture donc un filtrage supplémentaire qui n’est pas détecté par ladécomposition comme présentée dans l’exemple 3.1.

3.5.3 Dominance de l’edge-finding

Avec l’instance représentée par le réseau d’ordonnancement avec retards, une autre idée seraitde vouloir réutiliser le filtrage avec les composantes fortement connexes de Régin [23]. Toujoursdans l’optique d’avoir une solution non préemptive, en retirant une arête (e, i) reliant deuxcomposantes fortement connexes, il faut s’assurer que la tâche i ne puisse plus s’exécuterà l’instant e. Malgré la pertinence de ce raisonnement, il existe déjà dans la littérature desrègles de filtrage pour la contrainte Disjunctive qui appliquent ce raisonnement. La règle duedge-finding appliquée en duo avec le time-tabling sont notamment de bons candidats (voirsection 1.3.2). Cette section vise à présenter la dominance des algorithmes de filtrage pour lacontrainte Disjunctive vus jusqu’à maintenant par rapport au filtrage avec les composantesfortement connexes.

Théorème 3.3. Soit l’ensemble de tâches I et fmax le flot optimal obtenu du réseau d’ordon-nancement avec retards. La règle de l’overload checking détecte une incohérence si et seulementsi |fmax| < pI .

Démonstration. (⇒) Si l’overload checking soulève une incohérence, alors il existe un ensemblede tâches Ω tel que pΩ > lct Ω − est Ω. Or, dans le réseau d’ordonnancement avec retards,les capacités unitaires sur les arêtes émanant de la source empêchent de distribuer plus delct Ω − est Ω unités de flot sur les arêtes (i, t) tel que i ∈ Ω. Comme les arêtes (i, t) tel quei ∈ Ω ne peuvent pas être toutes saturées, la valeur du flot maximum |fmax| sera inférieure àpI .

(⇐) Si |fmax| < pI , alors il existe une tâche i dont l’arête (i, t) n’est pas saturée. Soit Θ

l’ensemble des tâches dans la même composante fortement connexe que la tâche i (i ∈ Θ) etsoit Ω = j : est Θ ≤ est j ∧ lct j ≤ lct Θ, alors pΩ > lct Ω− est Ω et l’overload checking détecteune incohérence.

Théorème 3.4. Le filtrage de la règle du edge-finding domine le filtrage avec les composantesfortement connexes.

Démonstration. Lors du filtrage du est i d’une tâche i, si le raisonnement avec les composantesfortement connexes engendre un filtrage, alors il y a une arête (e, i) reliant deux composantes

34

fortement connexes et telles que est i ≤ e < est i + pi. Aussi, il y a nécessairement une autretâche j ordonnancée à l’instant e et forcer l’exécution de la tâche i à l’instant e causerait undébordement. En reprenant le raisonnement de la preuve du théorème 3.3, soit Θ l’ensembledes tâches dans la même composante fortement connexe que la tâche j et soit Ω = j′ : est Θ ≤est j′ ∧ lct j′ ≤ lct Θ, alors pΩ + 1 > lct Ω − est Ω et est Ω ≤ e < lct Ω.

Dans tous les cas, si le raisonnement avec les composantes fortement connexes engendre unfiltrage du est i, Ω existe et est Ω∪i + pΩ∪i > lct Ω.

Cas 1 : est i ≥ est Ω

pΩ + 1 > lct Ω − est Ω ∧ est i ≥ est Ω ⇒ pΩ + 1 > lct Ω − est Ω∪i

⇒ pΩ∪i > lct Ω − est Ω∪i

⇒ est Ω∪i + pΩ∪i > lct Ω

Cas 2 : est i < est Ω. Soit k = est Ω − est i. Puisque est i ≤ e < est i + pi et est Ω ≤ e < lct Ω,alors k = est Ω − est i ≤ e− est i < est i + pi − esti = pi et donc 0 < k < pi.

pΩ + 1 > lct Ω − est Ω ∧ est i < est Ω ⇒ pΩ + 1 > lct Ω − (est Ω∪i + k)

⇒ pΩ + k + 1 > lct Ω − est Ω∪i

⇒ pΩ∪i > lct Ω − est Ω∪i 〈0 < k < pi〉

⇒ est Ω∪i + pΩ∪i > lct Ω

Par contraposition, s’il n’y a pas de tel ensemble Ω, alors le raisonnement avec les composantesfortement connexes n’apporte pas de filtrage. Or, un tel ensemble n’existe pas si la règledu edge-finding est cohérente. Par symétrie, cette idée peut être reprise pour démontrer ladominance avec le filtrage du lct i.

À l’issue de ce résultat, il est raisonnable de se concentrer sur le filtrage selon les retards.L’algorithme de filtrage présenté n’apporte pas de nouveau raisonnement quant à la satisfactionde la contrainte Disjunctive individuellement. Pour la suite, la contrainte Disjunctive seracohérente pour la plupart des instances présentées dans les exemples.

3.5.4 Analyse

La complexité en temps de l’algorithme à la section 3.5.2 est bornée par celle de l’algorithmede Régin [24]. Soit une instance modélisée par un réseau (N,A), la complexité de l’algorithmede plus court chemin choisi pour calculer les coûts réduits est notée P (|N |, |A|,W ) tel queW est le poids maximal d’une arête dans le réseau. Tel que mentionné à la section 2.3.2,l’algorithme de Régin [24] s’exécute en temps O(nP (|N |, |A|,W )) pour une instance de ntâches. L’algorithme de filtrage pour DisjunctiveTardiness présente la même complexité.

35

Cependant, dans ce contexte d’ordonnancement, la cardinalité de N et A dépend notammentde la taille des fenêtres d’exécution et des temps de traitement. L’analyse reprend les définitionsd’un problème d’ordonnancement de la section 1.3.1. Soit I les tâches pour une instance duproblème et n = |I|, alors :

h ∈ Ω(pI) h ∈ O(lct I − est I) |N | ∈ O(n+ h) = O(h) |A| ∈ O(nh)

L’ordre de grandeur pour l’horizon ne tient pas compte des instances non satisfiables. Ensupposant que l’algorithme de plus court chemin utilisé est Bellman-Ford qui s’exécute entemps O(|N ||A|), la complexité en temps final est alors en O(n2h2). Une taille est dite pseudo-polynomiale si sa valeur peut s’avérer supérieure à certaines limites numériques fixées. Puisqueles fenêtres d’exécution et les temps de traitement ont tous une taille pseudo-polynomiale, ilen résulte un algorithme dont le temps d’exécution pourrait être beaucoup trop grand pourle nombre de tâches à traiter. Par exemple, si les temps d’exécution sont exprimés avec uneprécision en millisecondes et que l’horizon est en heures, même avec quelques tâches, le réseaucompterait des milliers de nœuds et d’arêtes. Il est donc important de modifier le graphe pourobtenir de meilleurs temps d’exécution.

3.5.5 Flot forcé dans les parties fixes

Une amélioration envisageable pour le graphe est de forcer l’exécution des tâches dans leursparties fixes. Cette stratégie applique un raisonnement similaire à celui de la règle du time-tabling (voir section 1.3.2). Si la fenêtre d’exécution d’une tâche i est inférieure au double deson temps de traitement, c’est-à-dire |dom(Si)| − 1 < pi, il y des instants auxquels la tâchedoit nécessairement s’exécuter dans un ordonnancement valide. Le cas échéant, ce sont lesinstants compris dans l’intervalle [max(dom(Si)),min(dom(Si)) + pi). En forçant la tâche às’exécuter à ces instants, on peut réduire le nombre de nœuds et d’arêtes dans le réseau. Unefaçon de procéder est de retirer les arêtes concernées dans le graphe et de réduire la capacitéreprésentant les temps d’exécution en conséquence. Si forcer l’exécution à certains instantsengendre un retard, il faut en tenir compte dans le calcul de la borne du seuil T .

Exemple 3.3. Soit une instance pour la contrainte DisjunctiveTardiness avec deux tâchescomme suit :

DisjunctiveTardiness([Si, Sj ], [pi = 2, pj = 1], [di = 1, dj = 2], T )

dom(Si) = [0, 1], dom(Sj) = [0, 3], dom(T ) = [1, 2]

Exécuter l’algorithme sans flot forcé détermine un ordonnancement préemptif où la tâche 1s’exécute aux temps Ei = 0, 2 et la tâche 2 s’exécute au temps Ej = 1. Cet ordonnan-cement optimal engendre un retard relaxé de 1. Aucun filtrage n’est déclenché. En revanche,puisque |dom(Si)| − 1 = 2 − 1 < 2 = pi, la tâche 1 doit nécessairement s’exécuter dans l’in-tervalle [1, 2). Dans ce cas, le retard minimum pour un ordonnancement si 1 ∈ Ei est de 2

36

et permet d’affirmer que le retard est d’au moins T ≥ 2. Sans ce raisonnement, le seuil T neserait pas ajusté.

Un comportement intéressant est que lorsque le solveur branche sur une valeur Si = v, tousles nœuds d’instant dans l’intervalle [v, v + pi) sont retirés du graphe. En plus de réduire lataille du graphe, restreindre le flot de la sorte, renforce la relaxation et cause plus de filtrage.Cependant, cette technique n’est pas suffisante pour garantir que le graphe rapetisse à unetaille polynomiale.

3.6 Compression du graphe

Un problème potentiel affectant le temps d’exécution de l’algorithme est que chaque instantunitaire doit être représenté par un nœud dans le graphe. Comme l’horizon peut atteindre unetaille pseudo-polynomiale, c’est le nombre de nœuds d’instant qu’il faut réduire afin d’améliorerle temps d’exécution de l’algorithme. Une approche est de partitionner la fenêtre d’exécutionglobale. Chaque partition est formée d’instants consécutifs format un intervalle de temps. Lebut est de remplacer les nœuds d’instant par des nœuds d’intervalle. Cette approche permetde garder un contrôle flexible sur la taille du graphe.

Compresser les nœuds d’instant en intervalles disjoints requiert de faire des ajustements augraphe. D’abord, la source du réseau est maintenant reliée à des intervalles par des arêtesqui admettent autant de flot qu’il y a d’instants recoupés par l’intervalle relié. Autrementdit, soit un intervalle de temps Il,u = [l, u) contenant les instants l, l + 1, . . . , u − 1, alorsc(s, Il,u) = u − l. Ensuite, il y a une arête qui relie un intervalle Il,u à une tâche i si cettedernière peut s’y exécuter partiellement. Le cas échéant, la capacité de l’arête est :

c(Il,u, i) = min(u, lct i)−max(l, est i)

Au final, l’interprétation du flot dans le réseau est légèrement différente. La quantité de flotcirculant entre la tâche i et l’intervalle Il,u indique le nombre d’instants d’exécution de cettetâche dans l’intervalle Il,u. Soit f(Il,u, i) cette quantité, alors :

f(Il,u, i) = |Ei ∩ [l, u)|

Exemple 3.4. Soit l’instance de l’exemple 3.3 modifiée en augmentant d’un facteur de 10 laprécision de l’ordonnancement :

DisjunctiveTardiness([Si, Sj ], [pi = 20, pj = 10], [di = 10, dj = 20], T )

dom(Si) = [0, 10], dom(Sj) = [0, 30], dom(T ) = [0, 20]

40 nœuds d’instant sont requis pour représenter cette instance dans le graphe non compressé.La figure 3.2 montre un ordonnancement préemptif optimal des tâches dans un graphe résiduel

37

t

i

j

[0, 25)

[25, 30)

[30, 40)

s

20

10

5(0)

20(0)

5(1)10(2)

20(0)

5(0)

5(−1)

10(2)

25

5

10

Figure 3.2 – Graphe compressé pour l’exemple 3.3 avec seulement 3 nœuds de valeur

compressé. Le nombre de nœuds de valeurs passe de 40 instants à 3 intervalles. La capacité etle coût résiduel de chaque arête sont indiqués selon le format capacité(coût). Un exemple decalcul de capacité est :

c(I25,30, i) = min(30, 40)−max(25, 0) = 5

Le calcul du coût résiduel est expliqué à la section 3.6.1.

3.6.1 Impact sur la qualité de la borne

Un défaut de la compression du graphe est que cette technique diminue potentiellement laqualité de la borne sur le seuil T . La quantité de flot circulant entre les nœuds de tâcheet les nœuds d’intervalle n’est plus unitaire. Cette représentation cache l’ordre d’exécutionpréemptive des tâches à travers les intervalles. Par conséquent, il faut que le calcul du retardsoit plus relaxé que lorsque le graphe n’est pas compressé. Pour une tâche i s’exécutant dansun intervalle Il,u, un retard suffisamment optimiste selon la définition 3.1 est :

w(Il,u, i) = w(max(l, est i), i) ≤ w(e, i) tel que max(l, est i) ≤ e < u

Soit f(Il,u, i) le nombre d’instants d’exécution de la tâche i dans l’intervalle Il,u, le retardengendré par l’exécution de la tâche i dans l’intervalle Il,u est :

f(Il,u, i) · w(max(l, est i), i) ≤∑

e∈Ei∩[max(l,est i),u)

w(e, i)

Exemple 3.5. En reprenant la figure 3.2, un exemple de calcul de coût résiduel (poids entreparenthèses sur l’arête) est :

w(I25,30, i) = w(25, i) =

⌈max(0, 25 + 1− di)

pi

⌉=

⌈max(0, 25 + 1− 10)

20

⌉= 1

38

Bien que la taille du graphe soit réduite de façon substantielle, la qualité de la borne se retrouveimpactée par le choix du partitionnement des instants. Effectivement, une borne pour le retarddéterminée à partir du graphe non compressé est de 10, alors qu’elle n’est que de f(I25,30, j) ·w(I25,30, j) = 5 avec le graphe compressé de la figure 3.2. Un partitionnement permettant deretrouver la borne originale serait I0,10, I10,30 et I30,40. Dans ce cas, il devient possible deconsidérer les instants d’exécution en retard de la tâche i.

Un partitionnement judicieux de la fenêtre d’exécution globale est donc de mise pour maximiserla qualité de la borne. Trouver un partitionnement maximisant la qualité de la borne est unproblème d’optimisation qui s’avère complexe à lui seul. Dans le cadre de la résolution, ce choixdoit être fait rapidement pour que l’algorithme de filtrage s’exécute en un temps raisonnable.Les prochaines sections présentent deux heuristiques de compressions retenues.

3.6.2 Compression simple avec au plus 3n− 1 intervalles

Une heuristique simple est de définir un intervalle pour chaque est i, lct i et di parmi les tâchesI. Soit θ = est ini=1∪lct ini=1∪dini=1, les instants θ = t1, . . . , t|θ| triés en ordre croissantdéterminent le choix des intervalles. De chaque paire d’instants (tj , tj+1) résulte un intervalleItj ,tj+1. Ce partitionnement donne au plus 3n− 1 intervalles dans le cas où tous les est i, lct i

et di sont distincts.

Cette heuristique a certains avantages. D’abord, soit i ∈ I, elle simplifie le calcul des capacités :

c(Il,u, i) = min(u, lct i)−max(l, est i) = u− l = c(s, Il,u)

Puisque tout flot passant par une arête (Il,u, i) provient de l’arête (s, Il,u), c(s, Il,u) est lacapacité limitante. De ce fait, il n’est plus pertinent de borner la capacité sur les arêtes reliantles intervalles aux tâches et il devient redondant de fixer la capacité c(Il,u, i). Le calcul du coûtrésiduel est également plus simple. Les instants déterminants pour calculer les coûts résiduelssont les bornes inférieures des intervalles. :

w(Il,u, i) = w(max(l, est i), i) = w(l, i)

La coupure faite aux di permet d’assurer une qualité minimale de la borne sur le retard. Pardéfinition :

w(di, i) = w(di − 1, i) + 1 > w(di − 1, i)

Ainsi, pour une tâche i, chaque instant e ∈ Ei exécuté au-delà de l’échéance préférable diengendre un retard non nul.

Exemple 3.6. La figure 3.3 montre une version compressée du graphe de l’exemple 3.2. L’heu-ristique de la section 3.6.2 est utilisée pour choisir les intervalles. La capacité n’est pas bornée

39

t

i

j

[0, 2)

[2, 3)

[3, 4)

s

2

1

(1)

(2)

(0)

(1)

2

1

1

Figure 3.3 – Graphe compressé pour l’exemple 3.1 avec au plus 3n− 1 intervalles

pour le flot circulant entre une tâche et un intervalle. Les capacités des arêtes sortantes dela source et celles entrantes au puits sont indiquées. Les coûts résiduels sont indiqués entreparenthèses.

Le nombre de nœuds de valeurs passe de 4 dans le graphe non compressé à 3 dans le graphecompressé. Cette fois-ci le partitionnement maximise la qualité de la borne. Les coûts résiduelssont les mêmes que dans le graphe non compressé.

3.6.3 Compression aléatoire forçant 3n intervalles

Cette heuristique force un nombre minimal de 3n intervalles. Elle ne fait pas de raisonnementparticulier sur le choix des intervalles. L’idée est de compresser le graphe au préalable selonune autre heuristique (comme celle de la section 3.6.2) et de choisir au hasard des intervallessupplémentaires. Le tout est dans l’optique de ne pas obtenir un graphe trop compressé etainsi diminuer l’impact sur la qualité de la borne.

L’ajout d’un intervalle supplémentaire revient à faire une coupe dans un intervalle existant.Une coupe se fait en choisissant un instant k dans l’horizon qui n’est pas une borne d’unintervalle existant. Soit un intervalle Il,u tel que u > l + 1 et soit l’instant k ∈ Il,u \ l, cetintervalle est remplacé par les nouveaux intervalles Il,k et Ik,u. La stratégie aléatoire retenuedans le mémoire est de choisir uniformément selon les instants k disponibles.

3.6.4 Filtrage avec le graphe compressé

La compression permet de garder le contrôle sur la taille du graphe. Cependant, la valeurdu flot circulant dans le réseau peut toujours ne pas être bornée par un polynôme. Dans cecontexte, l’algorithme de Klein [17] permettant de calculer le flot maximum à coût minimum

40

s’exécute en temps pseudo-polynomial et il devient nécessaire de la remplacer par une variantepolynomiale, soit l’algorithme MinimumMeanCycleCancelingAlgorithm de Goldberg etTarjan [12]. L’algorithme 1 permet de filtrer le est des tâches. Par symétrie, le raisonnementest réutilisable pour filtrer les lct i.

Algorithme 1 : FiltrageEstGrapheCompressé((N,A), I, T )1 (N,Afmax)← MinimumMeanCycleCancelingAlgorithm((N,A))2 si |fmax| < pI alors3 soulever une incohérence

4 min(dom(T ))← max(min(dom(T )), cost(fmax))5 pour i ∈ I faire6 tableauCoûtPlusCourtsCheminsi ← Bellman-Ford((N,Afmax), i)7 pour (Il,u, i) ∈ Afmax et tel que l < est i + pi faire8 coûtRéduit ← tableauCoûtPlusCourtsCheminsi[Il,u] + w(Il,u, i)9 si coûtRéduit> 0 alors

10 quantitéFlotÀEnvoyer ← min(c(Il,u, i), est i + pi − l)

11 quantitéFlotAdmissible ←⌊

max(dom(T ))−cost(fmax)coûtRéduit

⌋12 si quantitéFlotÀEnvoyer > quantitéFlotAdmissible alors13 est i ← u− quantitéFlotAdmissible

14 Afmax ← Afmax \ (Il,u, i) : est i ≥ u

L’algorithme débute en calculant le flot maximum à coût minimum fmax du réseau d’ordon-nancement avec retards compressé (N,A). Tel que mentionné à la section 3.5.3, la validationà la ligne 2 est redondante si la règle de l’edge-finding est cohérente au préalable.

Les domaines des temps de début Si étant encodés par un intervalle, le filtrage est fait auxbornes. Aux lignes 4 et 13, l’opération ajuste la borne inférieure. L’algorithme peut souleverune incohérence si l’opération vide le domaine de la variable.

L’exécution de l’algorithme de Bellman-Ford à la ligne 6 retourne un tableau du coût desplus courts chemins dans le graphe résiduel. La requête au tableau à la ligne 8 de la formetableaui[Il,u] retourne le coût du plus court chemin (i→ . . .→ Il,u).

Pour que le est i d’une tâche i puisse être cohérent, il faut, pour chaque intervalle Il,u recoupantles instants [est i, est i+pi), pouvoir envoyer min(c(Il,u, i), est i+pi− l) unités de flot sur l’arête(Il,u.i) sans que cela ne cause un dépassement du seuil T . Pour effectuer cette validation, ilfaut trouver une borne supérieure sur la quantité de flot admissible qui peut être envoyée surune arête (Il,u.i). Une borne adéquate est basée sur le coût réduit d’un cycle optimal passantpar l’arête (Il,u.i). Si la quantité de flot à envoyer dépasse celle admissible, alors un filtrageest déclenché. Le cas échéant, la tâche doit débuter au plus petit instant tel qu’il n’est paspossible d’envoyer plus de flot que la quantité admissible pour l’intervalle Il,u. Au final, valider

41

un intervalle s’effectue en temps constant.

42

Chapitre 4

Expérimentations

Ce chapitre vise à comparer différentes versions de l’algorithme de filtrage présenté pour lacontrainte DisjunctiveTardiness. Ces variantes sont comparées avec l’approche naïve NDT

présentée à la section 3.2. La comparaison est faite en mesurant la performance lors de larésolution d’instances pour le problème PDT à la section 3.3. Une instance de ce problèmeest caractérisée par le tuple (I, T ) où I est l’ensemble ordonné des tâches et T est une bornesupérieure sur le retard admissible. Pour certaines instances, T =∞ et l’objectif est seulementde minimiser le retard. Lorsque T est fini, l’intérêt est de savoir si l’instance a une solutionet, le cas échéant, de minimiser le retard. Pour toutes les instances, esti = 0 et lcti =∞ pourtoutes les tâches i ∈ I. L’emphase est donc mise sur l’optimisation d’une solution plutôt quela recherche d’une solution réalisable.

Les implémentations ont été effectuées en utilisant le solveur Choco 4 [20]. Les expérimen-tations ont été exécutées sur le superordinateur Graham de Calcul Canada [3]. Sur chaqueprocesseur Intel E5-2683 v4 Broadwell cadencé à 2.1 GHz était allouée 28 800 MB de mémoirevive, soit 1 800 MB par coeur. Un coeur était alloué pour une instance à résoudre avec lesdifférents algorithmes à tour de rôle.

Les différents algorithmes à comparer sont d’abord présentés. Ensuite, chaque section carac-térise les instances du problème pour lesquelles les résolutions sont comparées. Les résultatsexpérimentaux sont analysés et suivis d’une discussion sur les travaux futurs.

4.1 Algorithmes comparés

Pour chaque instance (I, T ), un modèle, noté MDT , a été implémenté de la façon suivante :

43

minimize T

T ≥n∑i=1

max(0, Si + pi − di)

Disjunctive([S1, . . . , Sn], [p1, . . . , pn])

Les règles de l’edge-finding (implémentation de Vilím [28]) et du time-tabling (implémentationdisponible dans Choco 4 [20]) sont utilisées pour filtrer la contrainte Disjunctive.

Ce modèle est par la suite étendu avec la contrainte DisjunctiveTardiness pour laquelle 4

variantes sont utilisées pour la résolution :

— DT-NonCompressé est l’algorithme de base utilisant un graphe non compressé (Sec-tion 3.5.2) ;

— DT-NonCompresséAvecFlotForcé utilise un graphe compressé en forçant un flotdans les parties fixes (Section 3.5.5)

— DT-CompresséAuPlus3n utilise un graphe compressé ayant au plus 3n valeurs tellesque n est le nombre de tâches (Section 3.6.2)

— DT-Compressé3nPartiellementAléatoire utilise un graphe compressé ayant 3n

valeurs dont certaines sont déterminées aléatoirement (Section 3.6.3). L’heuristique debase utilisée est celle de la section 3.6.2.

4.2 Comparaison avec instances résolubles

Cette comparaison vise à illustrer la force du filtrage de la nouvelle contrainte. Les algorithmessont exécutés sur de petites instances de 10 tâches. Les instances sont générées aléatoirement.L’horizon de l’ordonnancement varie entre 40 et 80. Les instances sont résolues à l’optimum enau moins 10 secondes par un ou plusieurs des algorithmes comparés. Il s’agit donc de bonnesinstances pour comparer le filtrage et avoir un premier aperçu des temps de résolution.

L’heuristique de recherche affecte les variables en ordre lexicographique. L’ordre lexicogra-phique ne tient compte que de l’ordre initial des tâches en entrée pour une instance. Ce choixd’heuristique est pertinent pour évaluer la force du filtrage de façon indépendante.

Pour une résolution d’instance, le nombre de retours sur trace est proportionnel au nombrede nœuds visités lors de la recherche. Un algorithme qui engendre moins de retours sur traceindique qu’il a réduit l’espace de recherche, soit ce qui est causé par un filtrage tangible. Lenuage de points 4.1 montre, pour chaque instance, le nombre de retours sur trace effectués parune variante (axe vertical) comparé à celui de MDT (axe horizontal). Si un point se trouve

44

Nombre de retours sur trace pour la décomposition

Nom

bre

de re

tour

s su

r tra

ce

0

50000

100000

150000

200000

0 100000 200000 300000

DT-NonCompressé DT-NonCompresséAvecFlotForcé DT-CompresséAuPlus3nDT-Compressé3nPartiellementAléatoire MDT

Figure 4.1 – Nombre de retours sur trace de DisjunctiveTardiness par rapport à ladécomposition avec branchement en ordre lexicographique

sous la droite de référence, c’est que l’algorithme a fait moins de retours sur trace que MDT

et donc performe mieux.

Par souci de clarté, le graphique 4.1 n’englobe que les instances pour lesquellesMDT a causé auplus 400 000 retours sur trace. Comme envisagé, peu importe la variante, le nouvel algorithmefiltre plus que MDT . C’est d’ailleurs flagrant pour les variantes avec graphe non compressé. Àl’extrême, on retrouve une instance pour laquelle MDT engendre 13 072 975 retours sur tracealors que ce nombre ne s’élève qu’à 809 pour DT-NonCompressé et DT-NonCompressé-

AvecFlotForcé. Aussi, on remarque DT-CompresséAuPlus3n filtre moins que les autresvariantes. Effectivement, c’est la variante avec le graphe le plus compressé, ce qui réduit laqualité de la borne inférieure du seuil T . De plus, il est intéressant de constater que la varianteDT-Compressé3nPartiellementAléatoire a autant, et, parfois même, moins de retourssur trace que celles avec graphe non compressé. Le comportement aléatoire semble efficacepour, de temps à autre, partitionner l’horizon de sorte que la borne inférieure pour le seuil Tsoit près de celles déterminées par les variantes avec graphe non compressé. Ce résultat vientsoutenir l’idée que la qualité de la borne inférieure du seuil T exerce un rôle central dans lefiltrage selon les retards.

Le graphique 4.2 permet de mieux comparer les différentes variantes de l’algorithme de filtrage.Cette méthodologie est tirée de Houndji et collab. [15]. Plutôt que représenter chaque instance,

45

Facteur de performance contre le meilleur algorithme

Prop

ortio

n cu

mul

ée d

'inst

ance

s (%

)

0

25

50

75

100

1 2 3 4 5 6

DT-NonCompressé DT-NonCompresséAvecFlotForcéDT-CompresséAuPlus3n DT-Compressé3nPartiellementAléatoire

Figure 4.2 – Proportion cumulée d’instances pour lesquelles le nombre de retours sur traceest compétitif à un facteur près - MDT exclu

on note le meilleur algorithme pour chaque instance, soit celui ayant causé le moins de retourssur trace. Ensuite, on calcule à quel facteur près les autres algorithmes ont moins bien performé,soit combien de fois plus de retours sur trace ont été faits. Finalement, pour chaque algorithme,on cumule la proportion d’instances pour lesquelles celui-ci performe à un facteur près dumeilleur.

Le graphique 4.2 agrège les résultats de 134 instances résolues à l’optimum. Plus la courbe esthaute, mieux l’algorithme performe. Un exemple d’interprétation est que DT-NonCompressé-

AvecFlotForcé est au plus 1 fois moins bon que le meilleur algorithme pour 57% des ins-tances. Autrement dit, c’est le meilleur algorithme pour 57% des instances. D’ailleurs, on re-marque que DT-Compressé3nPartiellementAléatoire n’est presque jamais le meilleur.Une autre observation est que DT-Compressé3nPartiellementAléatoire est au plus 2fois moins performante pour 75% des instances.

Les variantes DT-NonCompressé et DT-NonCompresséAvecFlotForcé sont celles quiapportent le plus de filtrage. Visiblement, DT-NonCompresséAvecFlotForcé n’apportepas autant que prévu. D’ailleurs, forcer un flot dans les parties fixes complexifie l’implémen-tation lorsque le graphe est compressé. Puisque les avantages de cette variante ne pallient passuffisamment à ses désavantages, on en conclut qu’il n’est pas pertinent de l’employer avec ungraphe compressé.

46

La force du filtrage ne suffit pas pour démontrer qu’un algorithme est performant. Il fautnécessairement évaluer les gains en temps de calcul pour la résolution des instances. D’autresrésultats montrent qu’il y a un gain en temps de calcul pour une proportion tangible desinstances de 10 tâches. Cependant, ces instances de petite taille ne sont pas d’intérêt enpratique. Afin de mener cette évaluation, il faut plutôt comparer avec des instances de lalittérature qui tiennent compte des besoins en pratique. Cette évaluation est couverte à lasection suivante.

4.3 Comparaison avec instances de la littérature

Cette comparaison cherche à vérifier si les algorithmes sont pertinents en pratique. Les algo-rithmes sont exécutés sur 375 instances ayant entre 40 et 100 tâches. Les instances proviennentdes ouvrages de Congram et collab. [6]. Puisque l’on cherche à confirmer l’efficacité en pra-tique, le solveur est cette fois-ci configuré pour utiliser une heuristique de recherche accélérantla résolution. L’heuristique de base qui performe le mieux sur ces instances branche à la pluspetite valeur du temps de début Si dont la tâche i a la plus petite échéance préférable di :

Si ← min(dom(Si)) tel que i = arg mini∈I:|dom(Si)|>1

di (4.1)

L’heuristique retenue pour la résolution est cette heuristique de base étendue par le conflictordering search (COS) de Gay et collab. [11]. Le COS favorise la détection d’incohérences dansl’optique de filtrer plus souvent. Cette heuristique applique un raisonnement supplémentairesur l’heuristique de base.

Un temps limite de 10 minutes est alloué pour la recherche d’un ordonnancement optimal.Peu importe l’algorithme utilisé, la majorité des instances ne sont pas résolues à l’optimum.Seulement 18% sont résolues à l’optimum par l’un des algorithmes. De plus, lorsqu’une instanceest résolue à l’optimum, le temps de résolution est en moyenne moins de 5 secondes peuimporte l’algorithme. Cette efficacité est principalement due à l’heuristique de recherche 4.1choisie. L’horizon de l’ordonnancement varie entre 2 000 et 5 000. D’ailleurs, les algorithmesavec graphe non compressé ne sont pas comparés dans cette section. Effectivement, dû aucomportement pseudo-polynomial dépendant de la taille de l’horizon, les vitesses d’exécutionsont trop lentes. Ces variantes ne sont donc pas applicables en pratique.

Puisque les instances ne sont pas résolues à l’optimum, une première avenue est de comparerla meilleure solution retournée en utilisant chaque variante. La qualité d’un ordonnancementtrouvé est quantifiée par son retard. Compte tenu de la taille des instances, le retard estrarement nul pour les solutions retournées par le solveur.

Le graphique 4.3 montre la proportion cumulée d’instances pour lesquelles la qualité de lasolution est compétitive à un facteur près. Dans ce cas, il s’agit du retard. Si les variantesdonnent des solutions avec le même retard, la performance est jugée équivalente. En pratique,

47

Facteur de performance contre le meilleur algorithme

Prop

ortio

n cu

mul

ée d

'inst

ance

s (%

)

0

25

50

75

100

1,02 1,03 1,04 1,05 1,06

MDT DT-CompresséAuPlus3n DT-Compressé3nPartiellementAléatoire

Figure 4.3 – Proportion cumulée d’instances pour lesquelles le retard de la solution estcompétitif à un facteur près - COS avec branchement 4.1

le modèle MDT de base est toujours la meilleure méthode par rapport aux variantes avecgraphe compressé. Dans le cadre des expérimentations, c’est l’heuristique de recherche quisemble avoir le plus d’influence sur les temps de résolution. En effet, une heuristique qui faitde bons choix a moins besoin d’un algorithme de filtrage qui lui, retire les mauvais choix. Dece fait, la performance des algorithmes est semblable. La variante DT-CompresséAuPlus3n

donne une solution aussi bonne que celle avec le modèle MDT pour 86% des instances. Aussi,pour le reste des instances, la solution est au plus 1.05 fois moins bonne que celle avec MDT .

Pour la variante DT-Compressé3nPartiellementAléatoire la performance n’est pasautant similaire. La solution retournée est équivalente à celle de MDT dans 58% des cas. Lecomportement aléatoire semble mal réagir pour certaines instances. Le graphique 4.3 ne lemontre pas entièrement, mais pour 25% des instances, le retard d’une solution retournée estau moins 12 fois plus élevé que celle avec MDT .

Les résultats précédents mènent naturellement à vouloir déterminer quel algorithme performele mieux lorsque la qualité des solutions est équivalente pour une instance. Pour chaque ins-tance dont la solution a le même retard pour tous les algorithmes, on note le temps auquel lasolution est trouvée. Il s’agit d’une bonne façon de compléter la comparaison avec les instancesnon résolues.

Le graphique 4.4 montre la proportion cumulée d’instances pour lesquelles le temps pour

48

Facteur de performance contre le meilleur algorithme

Prop

ortio

n cu

mul

ée d

'inst

ance

s (%

)

0

25

50

75

100

2 4 6 8 10 12 14

MDT DT-CompresséAuPlus3n DT-Compressé3nPartiellementAléatoire

Figure 4.4 – Proportion cumulée d’instances pour lesquelles le temps pour obtenir une solu-tion compétitive est court à un facteur près - COS avec branchement 4.1

obtenir une solution compétitive est court à un facteur près. Ces résultats révèlent qu’avecla variante DT-Compressé3nPartiellementAléatoire, le solveur n’est jamais le premierà trouver une solution compétitive. De plus, la résolution est généralement plus lente. DT-

CompresséAuPlus3n est au plus 2 fois plus lent que le meilleur algorithme pour seulement10% des instances. À l’extrême, pour 25% des instances, DT-Compressé3nPartiellement-

Aléatoire est au moins 14 fois plus lent que le meilleur algorithme.

La lutte est plus au niveau du modèleMDT et de la variante DT-CompresséAuPlus3n. Dans30% des cas, DT-CompresséAuPlus3n est plus rapide. Cependant, lorsque c’est le cas, ellene se démarque pas autant. Le modèle MDT est au plus 5 fois plus lent que DT-Compressé-

AuPlus3n alors que ce facteur s’élève à 8 relativement à DT-CompresséAuPlus3n.

4.4 Travaux futurs

Il est motivant de constater la force du filtrage amené par les nouveaux algorithmes pour lacontrainte DisjunctiveTardiness. À ce niveau, les algorithmes avec graphe non compresséperforment à une magnitude plus élevée que le modèle de base MDT . En revanche, ce n’estpas autant remarquable pour les variantes avec graphe compressé qui demandent un sacrificesur la qualité de la borne inférieure pour le retard permis. Ce compromis demeure nécessaireà cause de la taille pseudo-polynomiale du graphe non compressé. Ainsi, pour aussi peu que

49

40 tâches, les variantes DT-NonCompressé et DT-NonCompresséAvecFlotForcé sontnécessairement écartées en pratique.

Les variantes DT-CompresséAuPlus3n et DT-Compressé3nPartiellementAléatoire

comportent un algorithme qui s’exécute en temps polynomial. De plus, le filtrage amené parDT-Compressé3nPartiellementAléatoire semble prometteur selon les résultats pour depetites instances. Cependant, ce n’est pas ce qui est révélé en pratique. Cette section énoncedes hypothèses justifiant ce résultat insatisfaisant. Aussi, certaines pistes de solutions sontfournies en conséquence.

4.4.1 Peaufiner l’heuristique de compression

Malgré ce qui est observé pour le filtrage, les résultats obtenus pour la variante DT-Compressé-

3nPartiellementAléatoire démontrent qu’il n’est pas suffisant de partitionner l’horizonaléatoirement. On peut également se questionner à savoir si toutes les coupures dans l’horizonpour la variante DT-CompresséAuPlus3n sont pertinentes. Le choix de l’heuristique à lasection 3.6.2 est notamment justifié par une simplification de l’implémentation du réseau deflot compressé. L’heuristique requiert notamment de couper dans l’horizon aux est i et lct i.Ces coupures ont pour effet de donner les formules simples de la section 3.6.2, mais elles n’ontpas d’impact direct sur la qualité de la borne. Les seuls instants de coupure pertinents pour laqualité de la borne sont dans t : est i ≤ t < lct i ∧ t = di + kpi : i ∈ I ∧ k ∈ N. À ces instantst, il existe une tâche i telle que le retard est w(t, i) = w(t− 1, i) + 1. Utiliser une heuristiquequi ne coupe qu’à ces instants de l’horizon nécessite une implémentation du réseau de flot quisupporte les définitions générales de la capacité et du coût résiduel de la section 3.6.

4.4.2 Réduire la borne sur le nombre d’intervalles

Il y a une deuxième raison probable justifiant la performance en pratique des variantes DT-

CompresséAuPlus3n et DT-Compressé3nPartiellementAléatoire. C’est peut-êtresimplement parce que le nombre d’intervalles est trop grand. Une approche serait de réduirele nombre à log(n) nœuds d’intervalle ou un nombre constant de noeuds plus petit que n.Cependant, il n’y pas de garantie à savoir si la compression ne pénaliserait pas trop la qualitéde la borne. Cette avenue est étroitement liée au peaufinage de l’heuristique de compressionproposé à la section 4.4.1. Une meilleure heuristique pourrait pallier aux conséquences d’unecompression accrue. Encore là, ne pas couper aux est i et lct i nécessite une implémentationdu réseau de flot qui supporte les définitions générales de la capacité et du coût résiduel de lasection 3.6.

4.4.3 Imposer davantage la non-préemption lors du filtrage

Cette réflexion s’inspire de la règle de l’edge-finding . Lors du filtrage de la fenêtre d’exécu-tion d’une tâche i, un algorithme simple appliquant la règle de l’edge-finding consiste, pour

50

chaque s ∈ Si, à fixer itérativement la fenêtre d’exécution de la tâche à [s, s+ pi) puis testerl’overload checking . Le nouveau est i est la plus petite valeur s telle que le test n’échoue pas.Par symétrie, le nouveau lct i est la plus grande valeur s telle que le test n’échoue pas. Leedge-finding empêche ainsi une préemption sur la tâche dont la fenêtre d’exécution est filtrée.La réflexion vient davantage spécialiser la contrainte pour les problèmes d’ordonnancementsans préemption.

Lors du filtrage du est i d’une tâche i dans le réseau d’ordonnancement avec retards, unedétection de filtrage plus sensible est envisageable. C’est applicable si, suite à la constructiond’un ordonnancement préemptif optimal, la tâche ne s’exécute pas sans interruption au débutde sa fenêtre d’exécution. C’est-à-dire si max(Ei) 6= est i + pi − 1. À ce moment, une exigencesupplémentaire est que le cycle optimal donnant un coût réduit rc′ passe par une arête (i, e)

telle que e /∈ [est i, est i + pi). Ce cycle existe si la règle de l’edge-finding est cohérente aupréalable. Puisque l’on considère moins de plus courts chemins, rc′ ≥ rc. D’ailleurs, un bénéficede cette approche est que l’on diminue le temps d’exécution de l’algorithme de plus courtchemin. En vérifiant un instant k, si le coût réduit rc′ cause un dépassement du seuil sur leretard, la nouvelle valeur du est i est min(min(Ei), k) + 1. Par symétrie, l’idée est applicablepour le filtrage du lct i. La nouvelle valeur du lct i est alors max(max(Ei), k).

Exemple 4.1. Un exemple trivial permet de montrer les bénéfices de ce filtrage plus sensible.Soit une instance avec une seule tâche :

DisjunctiveTardiness([Si], [pi = 2], [di = 1], T )

dom(Si) = [0, 1], dom(T ) = [1, 1]

t i

0

1

2

s1

1(0)

1(−1)

1(1)

1

1

1

Figure 4.5 – Flot optimal trivial

Le flot de la figure 4.5 encode un ordonnancement préemptif optimal pour la tâche. Lors dufiltrage du lct i, la contrainte sur la somme des retards du modèle de base MDT est suffisantepour déceler que la tâche i ne peut pas s’exécuter au temps 2. Cependant, cette incohérencen’est pas détectée par l’algorithme de filtrage, car le cycle optimal passant par l’arête (2, i)

51

est (i → 1 → s → 2 → i) et alors rc = 0. En revanche, en empêchant la préemption, lescycles passant par l’arête (i, e) telle que e ∈ [1, 3) sont écartés. Le cycle optimal est alors(i→ 0→ s→ 2→ i) et le coût réduit rc′ = 1 cause un dépassement du seuil T .

Dans un graphe compressé, ce nouveau raisonnement est encore plus pertinent. Avec l’al-gorithme 1, dès que l’ordonnancement préemptif exécute un instant d’une tâche i dans unintervalle Il,u, il n’y a plus de filtrage possible en fonction de l’intervalle. Effectivement, dansce cas, le cycle optimal est (i→ Il,u → i) et le coût réduit est nul à cause de la définition ducoût résiduel. Ce cycle pourrait être omis en empêchant la préemption sur la tâche i.

4.4.4 Adapter la fonction de coût à d’autres problèmes

Cette idée n’améliore pas les algorithmes de filtrage amenés dans la contribution. Il s’agitplutôt d’une proposition d’étendre leur application à d’autres variantes du problème PDT . Leretard est encodé par le coût résiduel d’une arête. Cette fonction peut facilement être adaptéepour des problèmes plus spécifiques. L’idée est que plus la fonction de coût est compliquée,moins les contraintes primitives sont suffisantes pour bien filtrer. Par exemple, s’il est désiréde répartir le retard entre les tâches, une solution est de spécifier une croissance quadratiquepour le retard d’une tâche. Une croissance de retard quadratique dissuaderait d’opter pour dessolutions dont certaines tâches dépassent l’échéance préférable de beaucoup. Dans ce contexte,les algorithmes de filtrage pourraient s’avérer compétitifs par rapport à une contrainte sur lasomme des retards au carré.

52

Conclusion

Ce mémoire est le fruit de travaux menés en programmation par contraintes appliqué à l’or-donnancement avec minimisation des retards. Intégrer une fonction de coût à la contrainteDisjunctive ne s’avère pas simple. Pour que le filtrage soit tangible, l’intégration semblenécessiter l’utilisation en boucle d’un algorithme de plus courts chemins, ce qui introduit descalculs additionnels. Dominé par la complexité en temps des algorithmes de réseaux de flot,l’algorithme de filtrage conçu pour la nouvelle contrainte globale DisjunctiveTardiness

n’est pas compétitif par rapport à une simple décomposition.

Certaines améliorations potentielles demeurent pertinentes à confirmer. D’abord, vu la flexi-bilité sur la taille du réseau, la complexité en temps de l’algorithme pourrait être réduiteen compressant davantage. D’ailleurs, l’heuristique de compression utilisée par l’algorithmepeut être améliorée. Aussi, un filtrage supplémentaire est envisageable en imposant davantagela non-préemption. Finalement, le plein potentiel de l’algorithme n’est peut-être pas atteintcompte tenu de la flexibilité offerte pour modéliser différents problèmes d’ordonnancementavec des fonctions objectifs autres que la somme des retards.

53

Annexe A

Glossaire

A.1 Notations du mémoire en ordre d’occurrence et groupéespar dépendance

Notation DescriptionCSP Problème de satisfaction de contraintesX Variable entière dans un CSPC Contrainte dans un CSP

dom(X) Domaine d’une variable entière Xmin(D) Valeur minimale d’un ensemble d’entiers Dmax(D) Valeur maximale d’un ensemble d’entiers DI Ensemble ordonné de tâches dans une instance pour un problème d’ordon-

nancementi ième tâche dans un ensemble ordonné ISi Variable entière indiquant à quel instant une tâche i débutep Temps de traitement d’une tâche ou d’un ensemble de tâches

est Plus petit instant auquel une tache ou un ensemble de tâches peut débuterdi Instant préférable auquel une tâche i devrait être terminéelct Instant limite auquel une tâche ou un ensemble de tâches doit être terminéeh Horizon d’un ensemble de tâchesCi Variable entière indiquant à quel instant une tâche i termineCmax Instant variable auquel toutes les tâches sont terminées (makespan)Ti Retard variable d’une tâche iw Valeur entière servant à pondérerTw,I Somme des retards pondérés variables d’un ensemble de tâches I

Tableau A.1 – Notation du chapitre 1

54

Notation Description[e1, . . . , en] Vecteur d’éléments(e1, . . . , en) Tuple d’éléments

#(v, τ) Nombre d’occurrences de la valeur v dans un tuple τcost Fonction de coûtH Seuil variable

P (n, d,W ) Complexité en temps pour un algorithme de plus court chemin arbitraire

Tableau A.2 – Notation du chapitre 1 (suite)

Notation Description(N,A) Graphe orientéN Ensemble de nœuds d’un graphe orientéA Ensemble d’arêtes d’un graphe orienté

(u, v) Arête allant du nœud u au nœud vf Flot valide qui circule dans un réseau

f(u, v) Quantité de flot qui circule sur l’arête (u, v)c(u, v) Capacité de l’arête (u, v)s Source d’un réseau de flott Puits d’un réseau de flot|f | Valeur du flot qui circule dans un réseau

(N,Af ) Graphe résiduelcf (u, v) Capacité résiduelle de l’arête (u, v)C Chemin dans un graphe résiduel

(s→ u→ t) Chemin passant par les nœuds s, u et t dans l’ordrefmax Flot valide dont la valeur est maximalew(u, v) Coût résiduel d’une arête (u, v)cost(u, v) Coût engendré par la circulation d’un flot sur l’arête (u, v)cost(f) Coût total du flot fX Ensemble de variablesV Ensemble de valeursrc Coût réduit engendré en poussant 1 unité de flot sur un cycle optimal

Tableau A.3 – Notation du chapitre 2

55

Notation DescriptionTI Somme des retards variables d’un ensemble de tâches IT Seuil du retard variable admis pour la contrainte DisjunctiveTardiness

NDT Décomposition non satisfaisante de la contrainte DisjunctiveTardinessPDT Problème encodé par la contrainte DisjunctiveTardiness

(I, T ) Instance pour la contrainte DisjunctiveTardiness ou le problème PDTTImin Retard d’une solution pour le problème PDTTI′min Retard d’une solution pour une relaxation du problème PDTEi Ensemble des instants unitaires auxquels une tâche i s’exécute dans un

ordonnancement préemptifw(e, i) Retard engendré l’exécution de la tâche i à l’instant eT ′i Retard variable relaxé d’une tâche iT ′s Retard relaxé d’une solution s pour le problème PDTTs Retard d’une solution s pour le problème PDT

(N,A) Le réseau d’ordonnancement avec retardsIl,u Intervalle de temps [l, u) recoupant les instants unitaires l, l + 1, . . . , u− 1

Tableau A.4 – Notation du chapitre 3

Notation DescriptionMDT Modèle du solveur pour résoudre le problème PDTCOS Heuristique de recherche conflict ordering search de Gay et collab. [11]

Tableau A.5 – Notation du chapitre 4

56

Bibliographie

[1] Ahuja, R. K., T. L. Magnanti et J. B. Orlin. 1993, Network flows : Theory, algorithms,and applications, chap. 6, Prentice Hall, p. 185.

[2] Ahuja, R. K., T. L. Magnanti et J. B. Orlin. 1993, Network flows : Theory, algorithms,and applications, chap. 7, Prentice Hall, p. 213–221.

[3] CalculCanada. 2017, «Graham», URL https://docs.computecanada.ca/wiki/Graham.

[4] Carlier, J. 1982, «The one-machine sequencing problem», European Journal of OperationalResearch, vol. 11, no 1, p. 42–47.

[5] Carlier, J. et E. Pinson. 1990, «A practical use of jackson’s preemptive schedule for solvingthe job shop problem», Annals of Operations Research, vol. 26.

[6] Congram, R. K., C. N. Potts et S. L. van de Velde. 2002, «An iterated dynasearch al-gorithm for the single-machine total weighted tardiness scheduling problem», INFORMSJournal on Computing, vol. 14, no 1, p. 52–67.

[7] Crauwels, H., C. N. Potts et L. N. Van Wassenhove. 1998, «Local search heuristics forthe single machine total weighted tardiness scheduling problem», INFORMS Journal oncomputing, vol. 10, no 3, p. 341–350.

[8] Fahimi, H. et C.-G. Quimper. 2014, «Linear-time filtering algorithms for the disjunctiveconstraint.», dans AAAI, p. 2637–2643.

[9] Ford, L. R. et D. R. Fulkerson. 1956, «Maximal flow through a network», Canadianjournal of Mathematics, vol. 8, no 3, p. 399–404.

[10] Garey, M. R. et D. S. Johnson. 1979, Computers and Intractability : A Guide to theTheory of NP-Completeness, W. H. Freeman.

[11] Gay, S., R. Hartert, C. Lecoutre et P. Schaus. 2015, «Conflict ordering search for sche-duling problems», dans International conference on principles and practice of constraintprogramming, Springer, p. 140–148.

57

[12] Goldberg, A. V. et R. E. Tarjan. 1989, «Finding minimum-cost circulations by cancelingnegative cycles», Journal of the ACM (JACM), vol. 36, no 4, p. 873–886.

[13] Graham, R. L., D. E. Knuth, O. Patashnik et S. Liu. 1989, Concrete mathematics : afoundation for computer science, 2e éd., AIP, 85 p..

[14] van Hoeve, W.-J. 2001, «The alldifferent constraint : A survey», arXiv preprintcs/0105015.

[15] Houndji, V. R., P. Schaus et L. Wolsey. 2019, «The item dependent stockingcostconstraint», Constraints, p. 1–27.

[16] Houndji, V. R., P. Schaus, L. Wolsey et Y. Deville. 2014, «The stockingcost constraint»,dans International conference on principles and practice of constraint programming, Sprin-ger, p. 382–397.

[17] Klein, M. 1967, «A primal method for minimal cost flows with applications to the assi-gnment and transportation problems», Management Science, vol. 14, no 3, p. 205–220.

[18] Le Pape, C. 1988, Des systèmes d’ordonnancement flexibles et opportunistes, thèse dedoctorat, Université Paris-Sud.

[19] López-Ortiz, A., C.-G. Quimper, J. Tromp et P. Van Beek. 2003, «A fast and simplealgorithm for bounds consistency of the alldifferent constraint», dans IJCAI, vol. 3, p.245–250.

[20] Prud’homme, C., J.-G. Fages et X. Lorca. 2017, Choco Documentation, TASC - LS2NCNRS UMR 6241, COSLING S.A.S. URL http://www.choco-solver.org.

[21] Quimper, C.-G., A. Golynski, A. López-Ortiz et P. Van Beek. 2005, «An efficient boundsconsistency algorithm for the global cardinality constraint», Constraints, vol. 10, no 2, p.115–135.

[22] Quimper, C.-G., A. López-Ortiz, P. Van Beek et A. Golynski. 2004, «Improved algorithmsfor the global cardinality constraint», dans International Conference on Principles andPractice of Constraint Programming, Springer, p. 542–556.

[23] Régin, J.-C. 1996, «Generalized arc consistency for global cardinality constraint», dansProceedings of the thirteenth national conference on Artificial intelligence-Volume 1, AAAIPress, p. 209–215.

[24] Régin, J.-C. 2002, «Cost-based arc consistency for global cardinality constraints»,Constraints, vol. 7, no 3-4, p. 387–405.

[25] Roberts, A. W. 1993, «Convex functions», dans Handbook of Convex Geometry, Part B,chap. 4.2, Elsevier, p. 1081–1104.

58

[26] Régin, J.-C. 1994, «A filtering algorithm for constraints of difference in csps», dans AAAI,vol. 94, p. 362–367.

[27] Tarjan, R. 1972, «Depth-first search and linear graph algorithms», SIAM journal oncomputing, vol. 1, no 2, p. 146–160.

[28] Vilím, P. 2007, Global constraints in scheduling, thèse de doctorat, Charles University,Faculty of Mathematics and Physics.

59