S Tremblay

HEURISTIQUES POUR LE PROBLÈME D’ORDONNANCEMENT
SUR UNE MACHINE MULTIPROCESSEUR
ESSAI - MBA GESTION MANUFACTURIÈRE ET LOGISTIQUE
Réalisé par
Simon TREMBLAY
Directeur
Jacques RENAUD
Faculté des Sciences de l’Administration

Université Laval
1er novembre 2008

Table des matières
1 Introduction ................................................................................................................. 4
2 Problématique ............................................................................................................. 6
3 Revue de littérature ................................................................................................... 12
4 Heuristique de construction ...................................................................................... 15
4.1 Étape 1 .............................................................................................................. 17

4.2 Étape 2 .............................................................................................................. 18
4.3 Étape 3 .............................................................................................................. 20
4.4 Étape 4 .............................................................................................................. 23
5 Double heuristique .................................................................................................... 25
5.1 Étape 2 .............................................................................................................. 27

5.2 Étape 3 .............................................................................................................. 29
6 Amélioration 2-Opt / 3-Opt ...................................................................................... 31
7 Résultats .................................................................................................................... 38
7.1 3 processeurs ..................................................................................................... 39

7.2 5 processeurs ..................................................................................................... 41
7.3 8 Processeurs ..................................................................................................... 44
8 Conclusion ................................................................................................................ 47
9 Références ................................................................................................................. 49
i
Liste des figures
Figure 2.1 : Semelle de caoutchouc .................................................................................... 6
Figure 2.2 : La machine multiprocesseur étudiée ............................................................... 7
Figure 2.3 : Vue aérienne de la machine multiprocesseur étudiée ..................................... 8
Figure 2.4 : Optimisation des couleurs individuellement ................................................. 10
Figure 2.5 : Ordonnancement en considérant la couleur suivante .................................... 10
Figure 2.6 : Ordonnancement horizon .............................................................................. 11
Figure 4.1 : Étapes de l’heuristique de construction de Boctor, Renaud & Ruiz ............. 16
Figure 4.2 : Étape 1 : Assignation des pointures initiales ................................................. 17
Figure 4.3 : Étape 2 : Mise de côté des pointures en demande dans le bloc suivant ........ 19
Figure 4.4 : Démonstration de l’heuristique de construction............................................ 21
Figure 4.5 : Étape 3 : Assignation des pointures disponibles ........................................... 22
Figure 4.6 : Étape 4 : Pointures mises de côté rendues disponibles ................................. 23
Figure 5.1 : Étapes du double heuristique ......................................................................... 26
Figure 5.2 : Étape 2 : Mise de côté des pointures ............................................................. 28
Figure 5.3 : Étape 3 : Assignation des pointures disponibles ........................................... 30
Figure 6.1 : Double heuristique avec bloc d’amélioration ................................................ 32
Figure 6.2 : Exemple d’ordonnancement d’un bloc de couleur ........................................ 33
Figure 6.3 : Positions possibles de déplacement de pointures .......................................... 34
Figure 6.4 : Échange entre les positions 3 et 7 ................................................................. 34
Figure 6.5 : Nouvelles positions ....................................................................................... 34
Figure 6.6 : Nouvel ordonnancement................................................................................ 35
Figure 7.1 : Déviation moyenne pour 3 processeurs......................................................... 40
Figure 7.2 : Déviation maximale pour 3 processeurs ....................................................... 41
Figure 7.3 : Nombre d’optimums pour 3 processeurs....................................................... 41
Figure 7.6 : Nombre de meilleurs pour 5 processeurs ...................................................... 44
Figure 7.9 : Nombre de meilleures solutions pour 8 processeurs ..................................... 46
ii
Liste des tableaux
Tableau 2.1 : Demande des pointures p pour trois couleurs de semelles ........................... 9
Tableau 6.1 : Exemple de possibilités d’échanges lors de l’optimisation 2-Opt .............. 35
Tableau 6.2 : Exemple de possibilités d’échanges lors de l’optimisation 3-Opt .............. 37
Tableau 7.1 : Résultats pour les problèmes à 3 processeurs ............................................. 40
iii
Chapitre 1 Introduction
1 Introduction
Cet essai traite du Problème d’Ordonnancement sur une Machine Multiprocesseur
(POMM). Une machine multiprocesseur est composée de plusieurs processeurs
homogènes qui sont utilisés pour traiter simultanément différents items d’un même
groupe. Les items traités sur la machine multiprocesseur doivent avoir les mêmes
caractéristiques de base telle que la couleur ou la composition au niveau des matières
premières. Pour ce qui est des items fabriqués sur les processeurs, ils peuvent différer au
niveau des caractéristiques mineures comme, par exemple, la taille, le modèle ou la
pointure fabriquée. Une des propriétés importantes de la machine multiprocesseur étudiée
dans le cadre de cet essai est que chaque fois que l’on effectue une mise en route
(ajustement, changements de moules, etc.) sur un processeur, tous les autres doivent être
également arrêtés.
Ce problème, avec les caractéristiques mentionnées, a été abordé à quelques reprises au

cours des dernières années par l’équipe de recherche composée de Boctor, Renaud &
Ruiz. D’ailleurs, cet essai fait suite au travail de Boctor, Renaud & Ruiz (2006). D’autres
travaux seront présentés lors de la revue de littérature. Dans leur article, les auteurs
proposent trois approches de résolution du problème. La première, une approche de
formulation mathématique, est en fait un modèle linéaire mixte en nombres entiers qui,
théoriquement, devrait mener à une solution optimale. Cependant, en pratique,
l’important nombre de variables rend son utilisation très fastidieuse. En fait, cette
approche ne permet de solutionner que des problèmes de petites tailles. La deuxième
approche, une heuristique de décomposition, élargit l’utilisation du modèle linéaire en
divisant le problème en plusieurs sous problèmes de taille plus réduite et qui peuvent être
résolus de façon optimale. Cette approche produit d’excellents résultats mais demande
malgré tout des temps de résolution relativement élevés et n’est pas nécessairement
facilement programmable. Finalement, la dernière approche est une heuristique de
construction. À l’aide de quelques règles simples, la solution est bâtie une étape à la fois.
Dans ce cas, les résultats s’obtiennent très rapidement mais sont moins intéressants en
terme de qualité.
Heuristiques pour le problème d’ordonnancement Page 4

sur une machine multiprocesseur
Chapitre 1 Introduction
Selon les auteurs, une avenue de recherche intéressante consisterait à mettre au point des
heuristiques qui permettent d’obtenir de meilleurs résultats tout en demeurant rapides.
Cet essai tente d’atteindre cet objectif en présentant une nouvelle heuristique se basant
sur l’heuristique de construction développée par Boctor, Renaud et Ruiz (2006) et en
mettant au point une méthode d’amélioration.
Le reste de ce document est composé des chapitres suivants. Au Chapitre 2, le problème

d’ordonnancement sur machine multiprocesseur est présenté de façon plus détaillée. Le
Chapitre 3 présente une courte revue de littérature sur le sujet. Étant donné que cet essai
se base sur l’heuristique de construction de Boctor, Renaud et Ruiz (2006), son
fonctionnement sera exposé au Chapitre 4. Par la suite, le Chapitre 5 présente la nouvelle
méthode développée. Le Chapitre 6 présente une méthode d’amélioration tentant
d’améliorer les résultats produits par la nouvelle heuristique. Le Chapitre 7 fait état des
résultats des différentes méthodes et les compare avec les approches développées
initialement par Boctor, Renaud et Ruiz (2006). Finalement, le Chapitre 8 présente les
conclusions.

Chapitre 2 Problématique
2 Problématique
Afin de faciliter la compréhension de la problématique, nous allons considérer le contexte
d’une machine multiprocesseur pour le moulage à injection, plus précisément pour la
production de semelles de bottes en caoutchouc. Typiquement, un manufacturier de ce
type de produits fabrique des semelles de C couleurs différentes dans P pointures. Les
pointures sont les mêmes pour toutes les couleurs de semelles. Les semelles sont
fabriquées en deux injections successives. Une première pour la partie inférieure, soit la
semelle proprement dite, et une deuxième pour la partie supérieure, qui recouvre le
dessus du pied, tel que présenté à la Figure 2,1.
2ième injection
1er injection
Figure 2.1 : Semelle de caoutchouc
Le procédé de fabrication est relativement simple. Sur une machine similaire à celle
présentée aux Figures 2.2 et 2.3, des moules, correspondant chacun à une pointure p, sont
fixés aux J processeurs de la machine qui sont en fait des bras d’injection. Les bras
tournent autour d’un axe central et, à tour de rôle, passent d’abord devant le premier
injecteur où la matière de la partie inférieure de la semelle est injectée dans le moule.
Suite à un déplacement permettant à la matière de se solidifier, le moule passe devant un
second injecteur où le reste de la semelle est fabriqué. Les bras poursuivent leur cycle
jusqu’au point final où les semelles sont retirées des moules. Ces mêmes moules
recommencent le cycle et c’est de cette façon que différentes pointures p d’une couleur c
sont produites simultanément. Le temps de production d’une semelle est le même, peu
importe la pointure. Ainsi, le temps de fabrication des semelles de pointure p et de
couleur c est uniquement fonction du nombre d’unités à produire. Évidemment, tous les

processeurs ne sont pas nécessairement utilisés en tout temps. Certains peuvent demeurer
libres pendant que d’autres sont occupés.
Généralement, le nombre de pointures P offertes par un manufacturier dépasse largement

le nombre de processeurs J disponibles sur une machine. Un opérateur doit donc effectuer
des changements de moules afin de couvrir la production d’un large éventail de pointures.
Ce temps de mise en course tp nécessaire au remplacement sur un processeur est le même,
peu importe le moule installé. Dans le cas des semelles, il est évident que le temps requis
pour installer le moule fabriquant une pointure 9 est le même que le temps nécessaire
pour une pointure 11.
Figure 2.2 : La machine multiprocesseur étudiée
Une particularité importante du POMM est que chaque fois qu’on doit effectuer un
changement de moule sur un processeur, tous les autres doivent également être arrêtés.
De plus, dans la plupart des situations pratiques, un seul changement de moule peut être
effectué à la fois puisqu’une seule personne en est responsable. Les changements de
moules sont donc effectués un à un et le temps est cumulatif.

Processeur j
2ième injecteur
1er injecteur
Moule de la pointure p
Fin du cycle Début du cycle
Figure 2.3 : Vue aérienne de la machine multiprocesseur étudiée
Une fois que toutes les pointures d’une couleur donnée ont été traitées, on doit effectuer
un autre type de mise en marche sur la machine. Un temps de mise en course tc est
nécessaire afin de changer la couleur de la matière qui sera injectée dans les moules, de
faire des ajustements et des nettoyages. Encore une fois, tc est le même peu importe la
couleur. Cependant, contrairement au nombre de changements de moules, le nombre de
ce type de mise en course ne dépend pas de l’ordonnancement et est toujours égal au
nombre de couleurs distinctes à produire (C) à l’intérieur de l’horizon de planification
considéré. Pour cette raison, il ne sera pas inclus dans le calcul des temps de production
puisqu’il s’agit d’une constante.
Finalement, un autre paramètre important du POMM est qu’il n’y a qu’un moule de
disponible par pointure. Comme c’est souvent le cas en industrie, le coût important
associé à l’achat de moules contraint les entreprises à optimiser l’utilisation de cette
ressource.
L’objectif relié au problème présenté dans cet essai est de partir d’une séquence de C
couleurs de semelles à fabriquer et d’établir la séquence de production des pointures sur

les différents processeurs pour chacune de ces couleurs de façon à minimiser le temps de
fabrication total. On doit donc établir quelle pointure sera produite sur quel processeur et
dans quel ordre. Le temps de fabrication total dépend quant à lui de deux éléments.
Premièrement, il dépend des durées de production de chacune des pointures
individuellement et deuxièmement, du nombre de mises en marche tp nécessaires.
Puisqu’une couleur n’est entièrement terminée que lorsque la dernière pointure est
fabriquée, le temps de fabrication d’une couleur est égal au temps où le dernier
processeur (moule) termine sa dernière tâche. Le temps de fabrication d’une couleur sera
donc égal au temps de production le plus long entre les processeurs qui inclus le temps
total de mise en marche des différentes pointures du bloc de couleur. L’objectif ultime est
donc d’établir un ordonnancement qui minimise la combinaison du temps de production
et du nombre de changements de moules.
Cet objectif de minimisation sur deux niveaux représente un défi intéressant. L’exemple
qui suit illustre la complexité et les particularités de cette situation. Le Tableau 2.1
présente une commande simplifiée pour quatre pointures dans trois couleurs différentes.
Supposons une machine à deux injecteurs.
p c1 c2 c3
1 100 - 50
2 - 10 -
3 20 - -
4 80 70 -
tp = 30
Tableau 2.1 : Demande des pointures p pour trois couleurs de semelles
La première façon d’ordonnancer cette commande consiste à traiter chacune des couleurs
individuellement et à minimiser leur temps de production. Cette méthode est illustrée à la
Figure 2.4 par un diagramme de Gantt où l’on indique à l’intérieur de chaque bloc de
production, soit l’activité du processeur (changement de moule, tp, ou pause), soit la
pointure fabriquée et le nombre d’unités produites. L’ordonnancement de la couleur c1
dans ce cas est optimal. De la même façon, on cédule les pointures pour les deux autres

couleurs et on obtient un temps de production total de 370 incluant cinq changements de

moules. En portant attention à l’ordonnancement des couleurs c1 et c2 sur le processeur
j1, on remarque que le fait d’insérer la pointure 3 entre la production de la pointure 4
dans les deux couleurs engendre deux changements de moules; un passage au moule 3
puis un retour au moule 4.
Figure 2.4 : Optimisation des couleurs individuellement
La Figure 2.5 illustre comment éliminer un de ces changements. À première vue, le fait
de déplacer la pointure 3 sur le processeur j2 semble être un mauvais choix. En effet, le
temps de production de cette couleur s’est allongé de 20 unités, passant de 160 à 180.
Cependant, le fait de laisser l’injecteur de la pointure 4 libre à la fin de la première
couleur (illustré en vert sur la figure) permet d’éliminer un changement de moule, soit
une économie de 30 unités. La considération des pointures en demande dans le bloc de
couleur suivant (la pointure 4 était commune aux deux blocs) a permis dans ce cas de
réduire le temps de production total de 10 unités.
Figure 2.5 : Ordonnancement en considérant la couleur suivante
Dans la solution précédente, le moule 4 est laissé libre à la fin du premier bloc car il est
également en demande dans le bloc suivant. Le Tableau 2.1 montre également que la
pointure 1 est en demande dans les blocs de couleur c1 et c3. La Figure 2.6 présente un
ordonnancement qui permet cette fois de garder la pointure 1 libre sur le processeur j2.
Comme on peut le voir, ce processeur n’est pas utilisé (section en vert du Gantt) lors de la

production de la couleur c2, ce qui permet d’éviter un changement de moule dans le bloc
3. La durée est ainsi réduite de 370 à 360 puis finalement à 350.
Figure 2.6 : Ordonnancement horizon
Cet exemple simple illustre bien les difficultés associées au POMM. L’objectif d’arriver à
un compromis satisfaisant entre le nombre de changements de moules et le temps de
production net des commandes est difficilement atteignable. La Figure 2.5 a démontré
que le fait d’accepter un temps de production plus long au premier bloc a permis de faire
des gains dans les blocs subséquents. Même chose à la Figure 2.6 où une décision au
premier bloc et une augmentation de temps de production au deuxième bloc ont permis
d’économiser suffisamment de temps au troisième bloc pour obtenir une solution plus
courte. En réalité, cette problématique devient extrêmement complexe. Tel que présenté
aux Figures 2.2 et 2.3, les machines multiprocesseurs comptent jusqu’à huit processeurs,
voir même dix. De plus, la gamme de produits des manufacturiers peut facilement
compter une douzaine de couleurs différentes et une vingtaine de pointures. Dans une
telle situation, chaque décision d’ordonnancement est susceptible d’avoir un impact
immédiat sur la solution en plus d’avoir des effets sur l’évolution de la structure de la
solution. La capacité de mesurer ces impacts lors des prises de décision sera donc un
facteur clé quant à la qualité des méthodes de résolution.

Chapitre 3 Revue de littérature
3 Revue de littérature
Au meilleur de nos connaissances, les travaux supervisés par l’équipe de recherche de
Boctor, Renaud & Ruiz sont les seuls qui se rapportent au problème d’ordonnancement
sur machine multiprocesseur tel que décrit aux chapitres précédents. Par contre, si l’on
considère les bras d’une machine multiprocesseur comme des machines parallèles, la
littérature est beaucoup plus abondante et les méthodes développées pour ce type
d’arrangement mécanique peuvent être exploitées dans le cadre de notre problème. La
seule différence étant que les temps de mise en route n’affectent pas toutes les machines
dans le cas d’arrangements en parallèle. Malgré tout, cette différence est suffisante pour
que les algorithmes ne puissent être utilisés sans adaptations majeures.
Les méthodes de résolution sur machines parallèles sont bien documentées. Cheng et Sin
(1990) ont d’ailleurs présenté une revue de littérature sur ce sujet. Ce type de problème
est NP-Complet et plusieurs heuristiques efficaces ont été développées. Cependant, deux
d’entres elles sont plus pertinentes à cet essai puisqu’elles ont servi de base pour
développer des approches au problème d’ordonnancement sur une machine
multiprocesseur traité dans ce document, tout en respectant l’objectif de minimisation du
temps de production.
Tout d’abord, Graham (1969) propose l’heuristique LPT (Longest Processing Time).
Cette méthode commence par trier les tâches à ordonnancer en ordre décroissant du
temps de traitement. Par la suite, elle assigne chaque tâche, dans l’ordre, à la première
machine disponible. En gardant les tâches les plus courtes pour la fin, cette heuristique
permet d’équilibrer la charge sur les différentes machines parallèles et ainsi, de minimiser
le temps de production total.
Coffman et al. (1978) présentent une méthode d’ordonnancement appelée MULTIFIT.

Cette méthode commence d’abord par fixer une valeur cible pour le temps de production
total. Par exemple, cette valeur peut correspondre au temps obtenu à l’aide de
l’heuristique LPT moins une unité de temps. Ensuite, tout comme dans le cas du LPT,
l’algorithme trie les tâches en ordre décroissant de temps de traitement. La prochaine

étape consiste à affecter chaque tâche, dans l’ordre, à la première machine capable de la
terminer avant la valeur cible. Si toutes les tâches ont été affectées avec succès, on refait
une autre itération, mais cette fois avec une valeur cible plus petite. S’il s’est avéré
impossible d’assigner toutes les tâches avant la date cible, l’algorithme s’arrête.
L’objectif de cette méthode est de trouver la valeur cible la plus petite permettant
l’affectation de toutes les tâches.
Dans les dernières années, des méthodes spécifiques au problème d’ordonnancement sur
machine multiprocesseur ont été mises au point à partir des deux heuristiques présentées
précédemment, toutes sous la supervision de l’équipe Boctor, Renaud et Ruiz. La toute
première application revient à Bouchard (2003) qui présente une méthode de planification
globale de la production d’une machine multiprocesseur dans le cadre d’une application
pratique pour une entreprise de fabrication de chaussures dans la région de Québec. À
l’intérieur de sa méthode générale, il propose trois heuristiques d’ordonnancement des
blocs de couleur. Premièrement, il applique la méthode MULTIFIT déjà mentionnée.
Ensuite, il développe deux procédures qui tiennent compte des moules déjà en place à la
fin du bloc précédent. La première procédure conserve chaque moule en place et leur
affecte directement la quantité à produire si une telle quantité existe. Les pointures
restantes sont assignées selon l’algorithme LPT. La deuxième procédure est similaire,
sauf qu’elle considère la possibilité de ne conserver qu’une partie des moules en place,
soit ceux qui correspondent aux quantités à produire les plus grandes. Encore une fois, le
reste des assignations est fait selon la méthode LPT. Bouchard (2003) se base donc sur
l’hypothèse que la machine multiprocesseur est similaire à un atelier de machines
parallèles et il adapte par la suite les solutions pour tenir compte de l’arrêt de tous les
processeurs lors d’un changement de moule. De plus, ses méthodes ne prévoient pas la
minimisation des changements de moules à venir dans les blocs de couleur subséquents.
Boustta (2003), quant-à-lui, tente de pallier à ces lacunes en développant un modèle

mathématique du problème et deux heuristiques. La modélisation mathématique permet
d’obtenir une solution optimale, mais est seulement développée pour des problèmes à
deux blocs de couleur. Même pour des problèmes de petites tailles, les temps de
résolution sont très longs et la méthode demeure difficile d’application dans le cadre de

cas pratiques. La première heuristique développée consiste tout d’abord à affecter les
pointures dont les moules sont déjà en place sur les processeurs. Par la suite, les pointures
restantes sont affectées selon la méthode MULTIFIT. La deuxième heuristique est une
méthode d’amélioration. L’algorithme fait tout d’abord l’ordonnancement des tâches à
l’aide de la méthode MULTIFIT. Ensuite, on tente d’éliminer des changements de
moules en changeant l’ordre des tâches sur les différents processeurs. Comme dans le cas
du modèle mathématique, ces heuristiques ne sont appliquées qu’à des problèmes à deux
blocs de couleur et sont relativement lentes à cause de l’aspect itératif de la méthode
MULTIFIT. Finalement, Boustta (2003) introduit la méthode de décomposition d’un
problème complet en sous-problèmes de 2 blocs avec un pas d’un bloc.
Rapp (2006), contrairement à ses prédécesseurs, ne tente pas seulement de solutionner le

problème d’ordonnancement pour une séquence de blocs donnés. Il tente plutôt de
développer des approches pour déterminer la meilleure séquence de production des blocs.
Il présente une heuristique basée sur l’affinité, une heuristique d’amélioration à voisinage
multiple, une heuristique de recherche tabou, une heuristique de recuit simulé et une
heuristique génétique. Toutes ces méthodes génèrent des séquences de blocs qui sont
ensuite ordonnancées en utilisant l’heuristique de construction de Boctor, Renaud & Ruiz
(2006).
Au meilleur de nos connaissances, aucune autre recherche sur ce problème

d’ordonnancement n’est disponible dans la littérature. Dans les chapitres suivants, nous
tentons donc de continuer à améliorer les approches existantes.

Chapitre 4 Heuristique de construction
4 Heuristique de construction
L’heuristique de construction conçue par Boctor, Renaud & Ruiz (2006) est en fait une
méthode reposant sur quatre règles de décision. Ces règles sont présentées à l’intérieur du
processus d’ordonnancement de la Figure 4.1 et visent à minimiser le temps de
production et le nombre de changements de moules. Les grandes lignes de l’heuristique
seront d’abord présentées et les grandes étapes seront par la suite détaillées davantage.
Au début d’un nouveau bloc de couleur, les derniers moules utilisés dans le bloc
précédant sont déjà en place sur les processeurs de la machine. À la première étape,
l’heuristique prend avantage de cette situation en assignant directement les pointures qui
sont en demande aux processeurs sur lesquels les moules correspondants sont déjà
installés. De cette façon, on évite des temps de mise en course inutiles.
Parmi les pointures qui n’ont pas été assignées à la première étape, on identifie celles qui
sont également en demande dans le bloc de couleur suivant et on les met de côté. C’est la
deuxième étape. La raison d’être de cette règle est fort simple. Elle repousse l’assignation
de ces pointures vers la fin du bloc de couleur, augmentant ainsi les chances d’éviter des
changements de moules entre le bloc en cours et le suivant.
Une fois que les pointures ont été mises de côté, l’heuristique procède à l’assignation des
pointures restantes. La méthode utilisée à cette troisième étape est détaillée davantage à la
section 4.3. Finalement, à l’étape 4, on rend les pointures mises de côté disponibles à
nouveau et on procède à leur ordonnancement de la même manière que les pointures
précédentes. Lorsque le bloc de couleur est complété, on passe au suivant jusqu’à ce que
la solution soit complète.

Début de l’heuristique de construction
Étape 1
Assigner les pointures dont le moule est déjà
installé sur un des processeurs
Étape 2
Mettre de côté les pointures qui sont
également en demande dans le bloc de
Passer au bloc de couleur suivant
couleur suivant
Étape 3
Assigner les pointures restantes
Étape 4
Rendre les pointures mises
de côté disponibles
Oui Est-ce qu’il y a des

pointures mises de côté?
Non
Oui Reste-t-il des blocs de

couleur à ordonnancer?
Non
Fin de l’heuristique de construction
Figure 4.1 : Étapes de l’heuristique de construction de Boctor, Renaud & Ruiz

4.1 Étape 1
À l’étape 1, on vérifie les pointures en demande dans le bloc de couleur courant à tour de
rôle. Si la pointure p vérifiée correspond à un des moules en place sur un des processeurs
de la machine, on assigne cette pointure au processeur. Sinon, on passe à la vérification
suivante. Une fois qu’une pointure est ordonnancée, on l’élimine de la liste des pointures
à produire, ce qui signifie qu’elle a été traitée et qu’on lui a assigné un processeur et un
ordre de passage sur la machine.
Figure 4.2 : Étape 1 : Assignation des pointures initiales

4.2 Étape 2
Comme à l’étape précédente, une vérification à tour de rôle de toutes les pointures
disponibles est faite afin d’identifier celles qui sont également en demande dans le bloc
de couleur suivant. Si c’est le cas, la pointure est mise de côté. L’objectif de cette étape
est d’augmenter les chances d’éviter des changements de moules entre deux blocs
consécutifs. Notons que le maximum de changements de moules possibles entre deux
blocs correspond au nombre de processeurs sur la machine. Il est donc inutile de mettre
de côté plus de pointures que le nombre de processeurs J. Le cas échéant, des pointures
doivent être rendues disponibles jusqu’à ce que le nombre de pointures mises de côté
corresponde au nombre de processeurs. Dans ce cas, la règle de sélection est le LPT
(Longest Processing Time), c’est-à-dire que les pointures ayant le plus d’unités à produire
redeviennent disponibles. De cette façon, on augmente les chances de se retrouver avec
de plus petites demandes à la fin des blocs de couleur, permettant ainsi un meilleur
équilibre d’utilisation des différents processeurs.

Début de l’Étape 2
Est-ce que la pointure p est Oui

également en demande dans le bloc
de couleur suivant?
Non
Passer à la pointure
Mettre la pointure de côté
suivante (p + 1)
Oui Reste-t-il des pointures à

vérifier?
Non
Y-a-t-il plus de pointures mises de Non

côté que le nombre de processeurs?
Oui
Identifier la pointure p mise de côté qui

à la demande la plus grande et la Fin de l’Étape 2
remettre disponible
Figure 4.3 : Étape 2 : Mise de côté des pointures en demande dans le bloc suivant

4.3 Étape 3
À l’étape 3, l’heuristique assigne les pointures disponibles aux processeurs en suivant une
procédure itérative. En fait, cette procédure est très similaire à la méthode LPT pour les
machines parallèles. À chaque itération, l’algorithme identifie d’abord la pointure p*
ayant la plus grande demande, donc le temps de production le plus long. Ensuite, il doit
assigner cette pointure au processeur le plus approprié. Au lieu de choisir seulement le
processeur j1 qui se libère en premier comme c’est le cas avec la méthode LPT standard,
l’algorithme considère également le processeur j2 qui se libère en deuxième comme
candidat potentiel pour recevoir p*. Ensuite, l’heuristique vérifie si l’assignation de p* à
j1 constitue le meilleur choix. Pour ce faire les éléments suivants sont analysés :
1. Si le moule présent sur j1 à ce moment ne correspond à aucune pointure dans le

bloc de couleur suivant, alors l’algorithme assigne p* à j1.
2. Si le moule présent sur j1 à ce moment correspond à une pointure en demande

dans le bloc de couleur suivant et si le fait d’assigner p* à j2 fait augmenter le
temps de production du bloc par plus de tp (temps nécessaire pour effectuer un
changement de moule), alors assigner p* à j1. Autrement l’algorithme assigne p*
à j2.
L’objectif d’utiliser un processeur supplémentaire comme candidat potentiel pour

l’assignation est d’éliminer des changements de moules. Prenons par exemple la Figure
4.4 où le temps de mise en course tp est égal à 30. La pointure 4 est tout d’abord assignée
au processeur 2 puisque le moule correspondant y est déjà (étape 1 de l’heuristique de
construction). Ensuite, la pointure 3 est mise de côté puisqu’elle est également en
demande dans le bloc de couleur c3 (étape 2 de l’heuristique de construction). Selon
l’étape 3, on doit ensuite assigner p5 puisque c’est la pointure restante avec la plus grande
demande (p*). Le processeur j1 se libère en premier et le moule qui s’y trouve ne
correspond à aucune pointure en demande dans le bloc de couleur c3. Alors, selon le
point 1 ci-dessus, on doit assigner la pointure 5 au processeur j1. Lorsque vient le temps
d’assigner la pointure 3, deux processeurs sont disponibles. Le processeur j3 s’est libéré
en premier et le processeur j1 en deuxième. La pointure 1 présente sur j3 est également

en demande dans le bloc de couleur c3. On doit donc se rapporter au point 2 ci-dessus. Si
on assigne la pointure 3 à j3, comme c’est le cas à la Figure 4.4 b), le nouveau temps de
production est de 140. Si on assigne la même pointure à j1, comme c’est le cas à la Figure
4.4 a), le temps de production est de 160. Le fait d’assigner p3 au deuxième processeur
disponible n’a donc pas fait augmenter le temps de production par plus de tp (30) donc,
l’heuristique assigne la pointure 3 à j1 et l’option a) est choisie.
Figure 4.4 : Démonstration de l’heuristique de construction
Dans ce cas, même si le temps de production du bloc courant est plus long de 20 unités
de temps, l’algorithme permettra d’éviter un changement de moule lors de l’assignation
des pointures du bloc de couleur c3 puisque le moule 1 est toujours sur le processeur j3.
Puisqu’un changement de moule correspond à 30 unités de temps, l’algorithme a donc
permis d’économiser 10 unités de temps.

Identifier la pointure disponible p* qui a la

demande la plus grande
Identifier le processeur j1 qui se libère en

premier
Identifier le processeur j2 qui se libère en

deuxième
Non
Est-ce que le moule sur j1 correspond à l’une ou l’autre des
pointures en demande dans le bloc suivant?
Oui
Est-ce qu’assigner la pointure p* à j2 au lieu de j1 Oui

augmente le temps de production total par plus du temps de Assigner p* à j1
mise en course tp?
Non
Assigner p* à j2
Oui Reste-t-il des pointures

disponibles?
Non
Fin de l’Étape 3
Figure 4.5 : Étape 3 : Assignation des pointures disponibles

4.4 Étape 4
L’étape 4 est quant à elle très simple. Elle consiste seulement à identifier les pointures qui
ont été mises de côté à l’étape 2 et à les remettre disponibles afin qu’elles puissent être
assignées à un processeur. L’assignation se fait selon la méthode de l’étape 3.
Oui
Est-ce que la pointure p est mise de côté?
Non
Passer à la pointure
Mettre la pointure p disponible
suivante (p + 1)
Oui Reste-t-il des pointures à

vérifier?
Non
Fin de l’Étape 4
Figure 4.6 : Étape 4 : Pointures mises de côté rendues disponibles
Pour des problèmes d’ordonnancement à blocs multiples, comme c’est le cas pour les
POMM, l’heuristique de construction proposée par Boctor, Renaud & Ruiz (2006) est
beaucoup plus performante qu’une application simple de la méthode du LPT à chaque
bloc puisqu’elle tient compte du bloc de couleur subséquent. Cependant, cet horizon de
recherche est très limité quand on considère qu’une douzaine de blocs de couleur peuvent
être traités un à la suite de l’autre. La Figure 2.6 rappelle également que même dans un

cas très simple, une décision prise au bloc de couleur c1 peut avoir un impact deux blocs
plus tard.
Le chapitre suivant présente une nouvelle méthode encore plus sophistiquée pour
résoudre le POMM. La contribution de cette méthode est que chaque décision est validée
de façon plus précise avant d’être implantée.

Chapitre 5 Double heuristique
5 Double heuristique
Essentiellement, l’heuristique de construction vue à la section précédente est composée
de deux catégories d’actions distinctes. Premièrement, aux étapes 1 et 2, l’algorithme fait
une pré-assignation des pointures en fonction du bloc de couleur précédent et du bloc de
couleur suivant, de manière à minimiser les changements de moules entre les blocs.
Deuxièmement, aux étapes 3 et 4, l’algorithme fait l’assignation des pointures à
l’intérieur des blocs de couleur afin de principalement minimiser les temps de production,
mais également de réduire le nombre de changements de moules.
L’objectif du double heuristique que nous proposons est d’agir sur ces deux types
d’action afin d’améliorer le processus de prise de décision. Pour ce faire, l’horizon
considéré sera beaucoup plus long qu’avec l’heuristique de construction de Boctor,
Renaud et Ruiz. En fait, en plus d’utiliser la structure générale de l’heuristique de
construction (Figure 5.1), cette même heuristique sera utilisée à un deuxième niveau lors
de la prise de décision de l’algorithme, d’où le nom de double heuristique.
Les différences entre cette nouvelle heuristique et la méthode de Boctor, Renaud et Ruiz
sont les suivantes. L’étape 1 reste la même, on assigne tout d’abord les pointures pour
lesquelles un moule est déjà en place sur un processeur. À l’étape 2, les pointures en
demande dans le bloc de couleur suivant sont encore mises de côté. Cependant,
l’algorithme s’assure que mettre une pointure de côté représente bien la meilleure
décision. Cette étape est vue plus en détail à la section suivante. L’étape 3 est également
similaire à celle de Boctor, Renaud et Ruiz sauf que cette fois, l’algorithme choisit la
meilleure combinaison d’une pointure et d’un processeur parmi toutes les combinaisons
disponibles (voir section 5.2). Finalement, une fois que les pointures mises de côté sont
rendues disponibles, l’algorithme vérifie encore toutes les combinaisons possibles avant
d’effectuer une assignation.
Donc, puisque seules les étapes 2 et 3 ont été modifiées, nous présentons, dans les
sections suivantes, uniquement les nouvelles versions de ces deux étapes.

Début de la double heuristique
Étape 1
Assigner les pointures dont le moule est déjà
installé sur un des processeurs
Étape 2
Mettre de côté les pointures qui sont
également en demande dans le bloc de
Passer au bloc de couleur suivant à l’aide de l’heuristique de
couleur suivant construction
Étape 3
Assigner les pointures restantes à l’aide de
l’heuristique de construction
Étape 4
Rendre les pointures mises
de côté disponibles
Oui Est-ce qu’il y a des

pointures mises de côté?
Non
Oui Reste-t-il des blocs de

couleur à ordonnancer?
Non
Fin de la double heuristique
Figure 5.1 : Étapes du double heuristique

5.1 Étape 2
Normalement, selon l’heuristique de construction, on devrait mettre une pointure de côté
si elle se retrouve également dans le bloc suivant. Cependant, l’utilisation de l’heuristique
de construction à un deuxième niveau permet de vérifier si cette décision est bel et bien la
meilleure. Prenons par exemple une pointure p qui se retrouve dans le bloc en cours et le
suivant. Dans un premier temps, on ne la met pas de côté et on complète
l’ordonnancement à partir de ce point et jusqu’à la fin du dernier bloc de couleur à l’aide
de l’heuristique de construction. Cet ordonnancement permet seulement de tester l’impact
de la décision sur le problème dans son ensemble. Seulement le temps de production T1
obtenu à l’aide de cet ordonnancement est conservé en mémoire. Ensuite, on met la
pointure p de côté, on complète l’ordonnancement et on obtient un temps de complétion
T2. En comparant T1 et T2 on choisira finalement l’option qui requiert le temps de
complétion total le plus cours et on appliquera la décision (mettre p de coté ou non) à
l’ordonnancement. La décision est donc moins myope car elle considère l’ensemble de la
suite du problème à résoudre.
En résumé, on considère l’impact d’une décision, prise à un moment donné, sur tous les
blocs de couleur restants et non seulement le bloc suivant, ce qui doit théoriquement
donner de meilleurs résultats.

Figure 5.2 : Étape 2 : Mise de côté des pointures

5.2 Étape 3
À cette étape, au lieu de considérer seulement une pointure et deux processeurs pour
l’assignation, comme c’est le cas pour l’heuristique de construction, la double heuristique
considère toutes les options possibles. Lorsque vient le temps d’assigner une pointure,
l’algorithme vérifie chacune des combinaisons pointure-processeur pj. Dans chaque cas,
un ordonnancement du problème complet est calculé et la valeur du temps de production
total correspondant Tpj est gardée en mémoire. L’algorithme choisi alors le temps Tpj le
plus bas et applique l’assignation de la pointure p au processeur j dans l’ordonnancement
réel.
En plus de considérer un plus grand nombre d’options, cette façon de faire considère
l’impact sur tous les blocs de couleur restants et non seulement le bloc suivant, ce qui
devrait encore une fois améliorer la solution obtenue à l’aide de la simple heuristique de
construction. La Figure 5.3 présente le détail de cette méthode.

Assigner chacune des pointures p disponibles à

chacun des processeurs j à tour de rôle et
mesurer le temps de production total Tpj résultant
de cette assignation à l’aide de l’heuristique de
construction
Identifier Tpj minimum
Assigner définitivement la pointure

p au processeur j
Oui Reste-t-il des pointures

disponibles?
Non
Fin de l’Étape 3
Figure 5.3 : Étape 3 : Assignation des pointures disponibles

Chapitre 6 Amélioration 2-Opt / 3-Opt
6 Amélioration 2-Opt / 3-Opt

La double heuristique présentée à la section précédente conserve le caractère constructif
de l’heuristique de Boctor, Renaud et Ruiz, c'est-à-dire que la solution est bâtie un bloc
de couleur à la fois sans retour en arrière. Par contre, l’avantage de cette nouvelle
méthode, comparativement à l’heuristique de construction, est qu’à chaque fois qu’elle
bâtit un bloc, elle prend en considération tous les blocs en aval et non seulement un.
Cependant, cette méthode demeure une heuristique et même si les décisions sont plus
éclairées, elles ne sont pas nécessairement optimales.
Afin d’améliorer la solution davantage, un module d’amélioration a été mis sur pied. Tel
que présenté à la Figure 6.1, le module d’amélioration s’insère dans la méthode double
heuristique (ou dans l’heuristique de construction). Une fois qu’on a construit
l’ordonnancement d’un bloc de couleur, on tente de l’améliorer avant de passer au bloc
suivant. Cette amélioration se fait à l’aide de méthodes que nous appelons 2-Opt et 3-Opt.
Les deux méthodes ne sont pas appliquées l’une à la suite de l’autre, mais séparément.
Ainsi, si l’on choisit la méthode 2-Opt, tous les blocs de couleur seront examinés à l’aide
de cette méthode. Encore une fois, ce module d’amélioration respecte le caractère
constructif de la méthode, puisqu’il s’applique sur un bloc à la fois, au fur et à mesure
que la solution est bâtie. La Figure 6.1 présente la position de la méthode d’amélioration
dans la double heuristique.

Figure 6.1 : Double heuristique avec bloc d’amélioration

Les procédures d’amélioration 2-Opt et 3-Opt fonctionnent sur le même principe de base.
La procédure du 2-Opt est présentée ci-dessous. Supposons que l’heuristique de
construction a produit un ordonnancement d’un bloc de couleur comme celui présenté à
la Figure 6.2.
190
3
j1 4 Pause 4 (40) Pause 4(20)
4
j2 8 tp 1(40) tp 2(40) tp 3(20)
5
j3 6
6
Figure 6.2 : Exemple d’ordonnancement d’un bloc de couleur
Dans ce cas, les pointures 4, 8 et 6, à gauche, correspondent aux moules qui sont déjà en
place sur les processeurs avant d’entreprendre l’ordonnancement du bloc de couleur
courant. Les pointures 3, 4, 5, 6 et 7, à droite, sont celles en demande dans le bloc
suivant. Afin de comparer cet ordonnancement à d’autres possibilités, on utilise la même
méthode que lors de l’assignation des pointures à l’étape 3 du double heuristique.
Premièrement, on complète l’ordonnancement à partir du bloc présenté à la Figure 6.2
jusqu’à la fin du dernier bloc de couleur à l’aide de l’heuristique de construction. Comme
dans le cas de la double heuristique, cette étape se fait en parallèle avec
l’ordonnancement réel. Cela permet d’obtenir un temps de complétion potentiel T1.
L’objectif du module d’amélioration est, par la suite, de vérifier s’il n’y a pas une
meilleure façon d’ordonnancer le bloc de couleur. On calcule donc le temps de
complétion potentiel pour chacun des ordonnancements créés suite à un échange entre
deux positions (pointures). Les positions possibles sont présentées à la Figure 6.3 (les
temps associés aux changements de moules ne sont pas présentés sur cette figure afin de
faciliter la compréhension). Une position peut correspondre à une pointure déjà en place
ou à une pointure additionnelle sur un processeur. Dans le cas présenté, il y a sept
positions possibles. Les échanges entre toutes ces positions seront évalués.

Figure 6.3 : Positions possibles de déplacement de pointures
On pourrait, par exemple, faire l’échange entre les positions 3 et 7. Ainsi, la pointure qui
se trouvait à la position 3 se retrouve maintenant sur le processeur j3 tel que présenté à la
Figure 6.4. Une fois qu’on a un nouvel ordonnancement, on calcule son temps de
complétion T2 à l’aide de l’heuristique de construction. On fait ensuite de même pour
tous les échanges possibles entre deux positions.
Figure 6.4 : Échange entre les positions 3 et 7
En admettant que T2 est le plus petit temps de complétion potentiel mesuré, la Figure 6.5
présente le nouvel ordonnancement ainsi que les nouvelles positions. On recommence
ensuite à explorer ce nouvel ordonnancement en évaluant tous les échanges possibles et
on continue cette séquence jusqu’à ce qu’il ne soit plus possible d’améliorer la solution
du bloc.
Figure 6.5 : Nouvelles positions

Dans ce cas, en admettant qu’il n’est plus possible de réduire le temps de complétion, on
obtient l’ordonnancement détaillé de la Figure 6.6 pour ce bloc de couleur.
Figure 6.6 : Nouvel ordonnancement
Pour la méthode 2-Opt, le nombre total d’échanges possibles entre deux positions dans un
bloc dépend évidemment du nombre de positions n et est égal à n2. Cependant, certains
des ces échanges ne sont pas pertinents.
Un exemple pour n = 4 est présenté au Tableau 6.1. Les échanges en vert représentent les
échanges pertinents, ceux en gris sont en fait des répétitions et ne sont donc pas
considérés. Les combinaisons en rouges sont rejetées puisqu’elles représentent des
échanges entre une seule position.
p1 p2 p1 p2 p1 p2 p1 p2
1 1 2 1 3 1 4 1
1 2 2 2 3 2 4 2
1 3 2 3 3 3 4 3
1 4 2 4 3 4 4 4
Tableau 6.1 : Exemple de possibilités d’échanges lors de l’optimisation 2-Opt
Ainsi, le nombre d’échanges pertinents possibles e2-Opt entre n positions est égal à la
sommation suivante :
n 1
e2Opt   i (6.1)
i 1

Dans la pire situation, c’est-à-dire dans le cas d’une machine à 8 processeurs et avec un
bloc de couleur ayant 20 pointures en demande, on obtient 28 positions disponibles, donc
378 échanges pertinents possibles.
La méthode du 3-Opt est basée sur le même principe que le 2-Opt, sauf qu’au lieu
d’effectuer des échanges entre deux positions, on utilise trois positions différentes.
Prenons par exemple le même ordonnancement où il y aurait 4 positions possibles de
déplacement (n = 4). Le Tableau 6.2 montre toutes les combinaisons d’échanges
possibles entre trois positions, soit un nombre égal à n3. Les échanges se font toujours de
p1 vers p2, p2 vers p3 et p3 vers p1. Encore une fois, ces échanges ne sont pas tous
pertinents. Les combinaisons en jaune correspondent aux échanges pertinents entre trois
positions et leur nombre est évalué à partir de la sommation suivante :
n 1
e3Opt   i (i  1) (6.2)
i 1
Les combinaisons en gris sont toutes des répétitions, soit 2-Opt, soit 3-Opt, puisque les
échanges sont toujours effectués dans le même sens. Évidemment, les combinaisons en
rouge sont rejetées puisqu’elles représentent des échanges entre une seule position. Les
combinaisons en vert correspondent quant à elles aux combinaisons présentées au
Tableau 6.1 dans la version 2-Opt. On peut donc dire que l’optimisation 3-Opt inclut
l’optimisation 2-Opt. Ainsi, le nombre total d’échanges pertinents qui doit être évalué
dans la méthode 3-Opt équivaut à la sommation suivante :
n 1 n 1 n 1
etotal   i   i (i  1)   i 2 (6.3)
i 1 i 1 i 1
Encore une fois, dans le cas où il y a 28 positions possibles, on obtient 6930 échanges
possibles. La méthode 3-Opt risque donc d’être considérablement plus longue que la
méthode 2-Opt, spécialement lors de l’utilisation de machines ayant un nombre de
processeurs élevé.

p1 p2 p3 p1 p2 p3 p1 p2 p3 p1 p2 p3
1 1 1 2 1 1 3 1 1 4 1 1
1 1 2 2 1 2 3 1 2 4 1 2
1 1 3 2 1 3 3 1 3 4 1 3
1 1 4 2 1 4 3 1 4 4 1 4
1 2 1 2 2 1 3 2 1 4 2 1
1 2 2 2 2 2 3 2 2 4 2 2
1 2 3 2 2 3 3 2 3 4 2 3
1 2 4 2 2 4 3 2 4 4 2 4
1 3 1 2 3 1 3 3 1 4 3 1
1 3 2 2 3 2 3 3 2 4 3 2
1 3 3 2 3 3 3 3 3 4 3 3
1 3 4 2 3 4 3 3 4 4 3 4
1 4 1 2 4 1 3 4 1 4 4 1
1 4 2 2 4 2 3 4 2 4 4 2
1 4 3 2 4 3 3 4 3 4 4 3
1 4 4 2 4 4 3 4 4 4 4 4
Tableau 6.2 : Exemple de possibilités d’échanges lors de l’optimisation 3-Opt

Chapitre 7 Résultats
7 Résultats
L’heuristique de construction, de Boctor, Renaud & Ruiz (2006), la double heuristique et
la méthode d’amélioration ont été codées à l’aide du langage C. Les algorithmes créés ont
été exécutés sur un ordinateur portable muni d’un processeur Intel Centino de 1,86 GHz
avec 1 Go de RAM.
Les méthodes présentées dans les chapitres précédents ont été testées sur des problèmes à
3 processeurs, 5 processeurs et 8 processeurs. Pour chacune de ces situations, 30
problèmes d’ordonnancement typiques ont été utilisés. Ces problèmes sont les mêmes
que ceux utilisés par Boctor, Renaud & Ruiz (2006) et permettent donc de comparer
l’efficacité des nouvelles méthodes avec celles développées antérieurement. Au total, 90
problèmes sont donc disponibles pour la base de comparaison.
Les Tableaux 7.1, 7.2 et 7.3 des sections suivantes présentent d’abord les résultats
obtenus par Boctor, Renaud & Ruiz (2006) à l’aide des deux heuristiques développées,
soit la méthode de décomposition, basée sur un programme linéaire résolu à l’aide de
CPlex sur un horizon roulant, ainsi que l’heuristique de construction. Par la suite, les
tableaux présentent les résultats obtenus à l’aide des nouvelles méthodes. Tout d’abord,
les modules d’amélioration 2-Opt et 3-Opt ont simplement été appliqués à l’heuristique
de construction. Finalement, la double heuristique appliquée seule est présentée, suivi de
la même méthode, mais cette fois, jumelée aux modules d’amélioration.
Les résultats contenus dans les tableaux qu’on retrouve aux sections suivantes sont
également présentés dans des figures qui illustrent le comportement des différentes
méthodes en fonction des trois principales mesures de performance, soit la déviation
moyenne, la déviation maximum et le nombre d’optimums ou de meilleurs résultats. Sur
chacune des figures, on remarque deux abscisses. L’axe supérieur se rapporte aux
courbes de l’heuristique de construction et de la double heuristique tandis que l’axe
inférieur se rapporte à la courbe de l’heuristique de décomposition.

7.1 3 processeurs
Dans le cas de la machine à 3 processeurs, les déviations moyennes et maximales
obtenues suite à la résolution des 30 problèmes sont calculées en fonction des solutions
optimales. En effet, le programme linéaire développé par Boctor, Renaud & Ruiz (2006)
a permis de résoudre tous les problèmes à 3 processeurs de manière optimale.
À l’analyse des résultats du Tableau 7.1 ainsi que des Figures 7.1, 7.2 et 7.3, on peut tout
d’abord remarquer que les méthodes d’amélioration permettent d’améliorer de façon
considérable les solutions obtenues à l’aide des différentes heuristiques. La méthode 3-
Opt génère de meilleurs résultats que la méthode 2-Opt. Cela respecte l’énoncé vu
précédemment selon lequel la méthode 3-Opt inclut la méthode 2-Opt. Si on n’utilise pas
les modules d’amélioration, la double heuristique donne quant à elle un meilleur résultat
que la simple heuristique de construction. De plus, la double heuristique accompagnée du
module d’amélioration 3-Opt permet d’égaler le meilleur résultat de 0,22% de déviation
moyenne obtenu avec la méthode de décomposition 1/4 (on résout à l’optimal avec 4
blocs, on ne conserve comme élément fixe que le premier bloc et on fait rouler l’horizon
d’optimisation). Cependant, la nouvelle méthode permet d’obtenir ce résultat en
beaucoup moins de temps. Il est aussi intéressant de noter que pour une même déviation
moyenne, les nouvelles méthodes développées génèrent des déviations maximales moins
grandes que les méthodes de décomposition, mais produisent par contre moins de
solutions optimales. Par exemple, pour une déviation moyenne de 0,35%, la méthode DH
2-Opt génère une déviation maximale de 2,14% comparativement à 3,37% pour la
méthode de décomposition 2/4. Par contre, elle ne produit que 20 solutions optimales
comparativement à 23. Le même phénomène est observé pour une déviation moyenne de
0,22%. On peut donc conclure que le comportement des nouvelles méthodes est plus
constant d’un problème à l’autre.

Heuristique Deviation moyenne Deviation maximum Nombre d'optimum Temps (sec)

1/1 5,53% 10,11% 1 <1
1/2 1,03% 4,23% 14 2
2/2 2,50% 7,69% 7 1
1/3 0,30% 2,14% 23 6
2/3 0,35% 2,14% 22 3
Décomposition
3/3 1,30% 4,29% 12 2
1/4 0,22% 2,80% 26 17
2/4 0,35% 3,37% 23 10
3/4 0,39% 3,37% 22 8
4/4 0,70% 3,37% 17 10
Construction 2,88% 10,26% 5 <1
Construction 2-Opt 1,14% 6,04% 13 <1
Double Heuristique 0,86% 5,00% 15 <1
DH 2-Opt 0,35% 2,14% 20 <1
DH 3-Opt 0,22% 1,43% 24 <1
Tableau 7.1 : Résultats pour les problèmes à 3 processeurs
Heuristique 2-Opt 3-Opt

6,00%
5,00%
Déviation moyenne
4,00%
Heuristique de décomposition
3,00% Heuristique de construction
Double heuristique
2,00%
1,00%
0,00%
1/1 1/2 2/2 1/3 2/3 3/3 1/4 2/4 3/4 4/4
Décomposition
Figure 7.1 : Déviation moyenne pour 3 processeurs


12,00%
10,00%
Déviation maximale
8,00%
Double heuristique
4,00%
2,00%
0,00%
1/1 1/2 2/2 1/3 2/3 3/3 1/4 2/4 3/4 4/4
Décomposition
Figure 7.2 : Déviation maximale pour 3 processeurs

30
25
Nombre d'optimums
20
Double heuristique
10
0
1/1 1/2 2/2 1/3 2/3 3/3 1/4 2/4 3/4 4/4
Décomposition
Figure 7.3 : Nombre d’optimums pour 3 processeurs
7.2 5 processeurs
Pour les problèmes à 5 processeurs, les déviations moyennes et maximales ne sont pas
calculées en fonction des solutions optimales. En effet, le programme linéaire développé
par Boctor, Renaud et Ruiz (2006) n’a réussi à résoudre aucun problème à 5 processeurs
de façon optimale, CPlex arrêtant faute de mémoire. Pour ces problèmes, les déviations

sont toujours calculées à partir des meilleures solutions obtenues par l’une ou l’autre des
méthodes étudiées dans le cadre de ce travail ou trouvées par Boctor, Renaud et Ruiz.
Comme on peut le remarquer au Tableau 7.2, et illustré par les Figures 7.4, 7.5 et 7.6, les
comportements de l’heuristique de construction, de la double heuristique et des méthodes
d’amélioration sont similaires dans le cas des machines à 3 ou 5 processeurs. Cependant,
pour la machine à 5 processeurs, les nouvelles méthodes n’arrivent pas à égaler le
meilleur résultat de 0,06% de déviation moyenne obtenu avec l’heuristique de
décomposition 1/3 en des temps de calculs moyens de 4953 secondes, ce qui est très long.
Également, l’heuristique de décomposition 2/3 présente un écart de 0,75% pour un temps
moyen de calcul de 7112 secondes. Pour ce qui est des nouvelles méthodes, la double
heuristique suivie du 3-Opt obtient malgré tout une déviation de 1,06% en une fraction de
seconde ce qui demeure un excellent compromis temps-qualité. Par rapport à la méthode
de construction de Boctor, Renaud et Ruiz qui obtient une déviation moyenne de 5,51%,
la double heuristique obtient 1,72%. Même lorsque les deux méthodes sont combinées au
3-Opt, les résultats de la double heuristique sont meilleurs à 1,06% contre 1,33%.
Finalement, il est intéressant de noter que les nouvelles méthodes ne semblent pas être en
mesure d’abaisser la déviation maximale qui demeure constante à 6,47%.
Heuristique Deviation moyenne Deviation maximum Nombre de meilleur Temps (sec)

1/1 10,21% 19,44% 0 2
1/2 1,60% 6,47% 9 33
2/2 4,63% 10,79% 1 69
Décomposition
1/3 0,06% 0,69% 27 4953
2/3 0,75% 4,32% 21 7112
3/3 2,71% 8,18% 3 10211
DH 2-Opt 1,36% 6,47% 10 <1
DH 3-Opt 1,06% 6,47% 12 <1


12,00%
10,00%
Déviation moyenne
8,00%
Double heuristique
4,00%
2,00%
0,00%
1/1 1/2 2/2 1/3 2/3 3/3
Décomposition

25,00%
20,00%
Déviation maximale
15,00% Heuristique de décomposition

Heuristique de construction
10,00% Double heuristique
5,00%
0,00%
1/1 1/2 2/2 1/3 2/3 3/3
Décomposition


30
25
Nombre de meilleurs
20
Double heuristique
10
0
1/1 1/2 2/2 1/3 2/3 3/3
Décomposition
Figure 7.6 : Nombre de meilleurs pour 5 processeurs
7.3 8 Processeurs
Comme pour les problèmes à 5 processeurs, les déviations pour le cas à 8 processeurs
sont calculées à partir des meilleures solutions obtenues par l’une ou l’autre des méthodes
étudiées.
Encore une fois, comme le montre les Figures 7.7, 7.8 et 7.9, les relations entre les
différentes heuristiques développées sont constantes. De plus, à l’étude du Tableau 7.3,
on remarque que la méthode Double Heuristique (DH) 3-Opt offre de très bons résultats.
La déviation moyenne obtenue de 0,60% (en une fraction de seconde) est comparable au
meilleur résultat de 0,55% obtenu à l’aide de l’heuristique de décomposition 1/2 qui
nécessite cependant 4179 secondes en moyenne. Cela lui donne un net avantage.
Tout comme dans le cas de la machine à 3 processeurs, les données du tableau montrent
que les nouvelles méthodes développées génèrent des déviations maximales moins
grandes que les méthodes de décomposition, mais produisent par contre moins de
meilleures solutions. Dans ce cas, pour une déviation moyenne entre 0,55% et 0,60%, la
méthode DH 3-Opt génère une déviation maximale de 2,78% comparativement à 4,0%
pour la méthode de décomposition 1/2. Par contre, elle ne produit que 13 meilleures
solutions comparativement à 18. Par rapport à la méthode de construction de Boctor,
Renaud et Ruiz qui obtient une déviation moyenne de 6,60%, la double heuristique

obtient 2,55%. Même lorsque les deux méthodes sont combinées au 3-Opt, les résultats
de la double heuristique sont meilleurs à 0,60% contre 1,20%.
Finalement, des temps d’exécution d’environ 1 seconde pour les méthodes impliquant
l’amélioration 3-Opt présentées dans le tableau confirment les affirmations du Chapitre 6
selon lesquelles le nombre important d’échanges possibles entre les n positions risque
d’engendrer des temps d’exécution plus longs (même si ce temps est malgré tout infime
comparativement à l’approche de décomposition basée sur le modèle linéaire).
Heuristique Deviation moyenne Deviation maximum Nombre de meilleur Temps (sec)

1/1 13,48% 19,81% 0 18
Décomposition 1/2 0,55% 4,00% 18 4179
2/2 3,80% 7,14% 1 3450
Construction 3-Opt 1,20% 3,64% 8 1
DH 2-Opt 1,35% 4,84% 7 <1
DH 3-Opt 0,60% 2,78% 13 1

16,00%
14,00%
Déviation moyenne
12,00%

4,00%
2,00%
0,00%
1/1 1/2 2/2
Décomposition


25,00%
20,00%
Déviation maximale

Heuristique de construction
5,00%
0,00%
1/1 1/2 2/2
Décomposition

20
18
16
Nombre de meilleurs
14
12 Heuristique de décomposition
8 Double heuristique
6
4
2
0
1/1 1/2 2/2
Décomposition
Figure 7.9 : Nombre de meilleures solutions pour 8 processeurs

Chapitre 8 Conclusion
8 Conclusion
En conclusion de leur travail, Boctor, Renaud et Ruiz (2006) suggèrent qu’il serait
possible de concevoir des heuristiques capables de produire de meilleurs résultats que ce
qu’ils présentent et de manière plus rapide pour résoudre le POMM. L’objectif de cet
essai consistait donc à explorer cette possibilité. Afin d’y arriver, l’heuristique de
construction a été utilisée comme point de départ. L’idée était de tirer profit de son
avantage principal, soit sa simplicité et sa vitesse d’exécution, tout en tentant de la rendre
plus performante. Pour ce faire, on devait cibler la principale faiblesse de cette méthode.
En fait, le problème avec l’heuristique de construction est qu’elle ne tient pas compte
d’un horizon de temps assez grand. Lors des prises de décision de l’algorithme,
seulement le bloc de couleur suivant est considéré. Or, on a démontré que les effets d’une
décision peuvent se faire ressentir plus loin dans l’ordonnancement. Pour imager la
situation, on pourrait dire que l’heuristique était myope et qu’il fallait la munir de lentille
corrective.
C’est exactement le but que nous avons atteint avec la double heuristique. L’utilisation de
l’heuristique de construction à un deuxième niveau nous permet de mesurer rapidement
l’impact d’une décision sur l’ensemble du problème et ainsi de faire de meilleurs choix.
Dans tous les cas, on a été en mesure d’améliorer les résultats de façon considérable, tout
en n’affectant pas significativement le temps d’exécution. Alors que la méthode de
construction de Boctor, Renaud et Ruiz obtenait des déviations moyennes de 2,88%,
5,51% et 6,60% pour les problèmes à 3, 5 et 8 processeurs, la DH obtient respectivement
des déviations de 0,86%, 1,72% et 2,55%.
En deuxième lieu, on désirait vérifier s’il était encore possible d’améliorer les solutions.
Une fois de plus, afin de ne pas affecter les temps d’exécution, la simplicité était
primordiale. Pour ce faire, des méthodes d’amélioration 2-Opt et 3-Opt ont été
développées. Dans tous les cas, les résultats démontrent l’efficacité de ces méthodes qui
réussissent à améliorer les solutions. Pour les problèmes à 3, 5 et 8 processeurs, la DH 3-
Opt obtient des déviations de 0,22%, 1,06% et 0,60%.

Chapitre 8 Conclusion
En conclusion, cet essai démontre qu’il est possible de résoudre des problèmes
d’ordonnancement sur une machine multiprocesseur (POMM) de manière très efficace
avec des heuristiques simples et très rapides. Principalement, il a été possible d’arriver à
de tels résultats en se servant d’une seule heuristique de base et en l’utilisant sur deux
niveaux, le deuxième servant à valider les choix du premier.

Chapitre 9 Références
9 Références
FRANÇOIS BOUCHARD, Maîtrise en administration des affaires, Faculté des sciences
de l'administration, Université Laval, codirection avec M. Fayez Boctor. Titre du
mémoire : Planification de la production sur une machine multitâche : cas de l'entreprise
Régence, 2003.
MOHAMED BOUSTTA, Maîtrise en administration des affaires, Faculté des sciences de

l'administration, Université Laval, codirection avec M. Angel Ruiz. Titre du mémoire :
Minimisation du temps de fabrication sur une machine à injection avec réglages
multiples, juillet 2003.
RAPP J-E., Maîtrise en administration des affaires, Faculté des sciences de

l'administration, Université Laval, codirection avec M. Fayez Boctor et M. Jacques
Renaud. Titre du mémoire : Détermination de la séquence de production sur une machine
à injection: Une étude comparative de diverses approches de recherche dans le voisinage,
2006.
BOCTOR F., RENAUD J. et RUIZ A., Optimal and Heuristics Solution Methods for a
Multi-Processor Machine Scheduling Problem, Document de travail, Faculté des sciences
de l’administration, 2006.
CHENG, T.C.E. et SIN, C.C.S., ‘A State-Of –The-Art Review of Parallel Machine

Scheduling Research’, European Journal of Operational Research, 47, 1990, 271-292.
COFFMAN et AL, Coffman E.G., Garey M.R. et Johnson D.S., An application of bin-packing to
multi-processor scheduling, SIAM Journal of Computing, 17, 1978, 1-17.
GRAHAM R.L., Bounds on multiprocessing timing anomalies, SIAM Journal of Applied

Mathematics, 17, 1969, 263-269.


S Tremblay

Transféré par

Informations du document

Titre original

Copyright

Formats disponibles

Partager ce document

Partager ou intégrer le document

Options de partage

Avez-vous trouvé ce document utile ?

Ce contenu est-il inapproprié ?

Droits d'auteur :

Formats disponibles

S Tremblay

Transféré par

Droits d'auteur :

Formats disponibles

HEURISTIQUES POUR LE PROBLÈME D’ORDONNANCEMENT

SUR UNE MACHINE MULTIPROCESSEUR

ESSAI - MBA GESTION MANUFACTURIÈRE ET LOGISTIQUE

Faculté des Sciences de l’Administration

1er novembre 2008

4.1 Étape 1 .............................................................................................................. 17

5.1 Étape 2 .............................................................................................................. 27

7.1 3 processeurs ..................................................................................................... 39

Ce problème, avec les caractéristiques mentionnées, a été abordé à quelques reprises au

Heuristiques pour le problème d’ordonnancement Page 4

Le reste de ce document est composé des chapitres suivants. Au Chapitre 2, le problème

Heuristiques pour le problème d’ordonnancement Page 5

Figure 2.1 : Semelle de caoutchouc

Heuristiques pour le problème d’ordonnancement Page 6

Généralement, le nombre de pointures P offertes par un manufacturier dépasse largement

Figure 2.2 : La machine multiprocesseur étudiée

Heuristiques pour le problème d’ordonnancement Page 7

Fin du cycle Début du cycle

Figure 2.3 : Vue aérienne de la machine multiprocesseur étudiée

Heuristiques pour le problème d’ordonnancement Page 8

Tableau 2.1 : Demande des pointures p pour trois couleurs de semelles

Heuristiques pour le problème d’ordonnancement Page 9

couleurs et on obtient un temps de production total de 370 incluant cinq changements de

Figure 2.4 : Optimisation des couleurs individuellement

Figure 2.5 : Ordonnancement en considérant la couleur suivante

Heuristiques pour le problème d’ordonnancement Page 10

Figure 2.6 : Ordonnancement horizon

Heuristiques pour le problème d’ordonnancement Page 11

Coffman et al. (1978) présentent une méthode d’ordonnancement appelée MULTIFIT.

Heuristiques pour le problème d’ordonnancement Page 12

Boustta (2003), quant-à-lui, tente de pallier à ces lacunes en développant un modèle

Heuristiques pour le problème d’ordonnancement Page 13

Rapp (2006), contrairement à ses prédécesseurs, ne tente pas seulement de solutionner le

Au meilleur de nos connaissances, aucune autre recherche sur ce problème

Heuristiques pour le problème d’ordonnancement Page 14

Heuristiques pour le problème d’ordonnancement Page 15

Début de l’heuristique de construction

Oui Est-ce qu’il y a des

Oui Reste-t-il des blocs de

Fin de l’heuristique de construction

Figure 4.1 : Étapes de l’heuristique de construction de Boctor, Renaud & Ruiz

Heuristiques pour le problème d’ordonnancement Page 16

Figure 4.2 : Étape 1 : Assignation des pointures initiales

Heuristiques pour le problème d’ordonnancement Page 17

Heuristiques pour le problème d’ordonnancement Page 18

Est-ce que la pointure p est Oui

Oui Reste-t-il des pointures à

Y-a-t-il plus de pointures mises de Non

Identifier la pointure p mise de côté qui

Heuristiques pour le problème d’ordonnancement Page 19

1. Si le moule présent sur j1 à ce moment ne correspond à aucune pointure dans le

2. Si le moule présent sur j1 à ce moment correspond à une pointure en demande

L’objectif d’utiliser un processeur supplémentaire comme candidat potentiel pour

Heuristiques pour le problème d’ordonnancement Page 20

Figure 4.4 : Démonstration de l’heuristique de construction

Heuristiques pour le problème d’ordonnancement Page 21

Identifier la pointure disponible p* qui a la

Identifier le processeur j1 qui se libère en

Identifier le processeur j2 qui se libère en

Est-ce qu’assigner la pointure p* à j2 au lieu de j1 Oui

Oui Reste-t-il des pointures

Figure 4.5 : Étape 3 : Assignation des pointures disponibles

Heuristiques pour le problème d’ordonnancement Page 22