Institut Supérieur des Matériaux et Mécaniques Avancés Avancés 44 avenue F.A Bartholdi – 72000 Le Mans Tél: 02 43 21 40 00 – Fax: 02 43 21 40 39 e-mail:
[email protected] http://www.ismans.fr
Projet : Ingénierie numérique MATLAB ®. Recherche de chemin critique en ordonnancement
Tuteur : Monsieur El Kaabouchi Chef de Projet : Meyer Michaël Groupe: Chauvet Floriane Allard Jean-François Bazin Frédéric Bianchini Rémi Celli Marc-Antoine Girault Nicolas
Année 2008/2009
Table des matières
I Abstract......................................................................................................................................................... .2 II Remerciements............................................................................................................................................ .2 III Introduction............................................................................................................................................... .3 IV Présentation générale.................................................................................................................................. .3 IV.1 IV.1 Définition de l'ordonnancement............................... l'ordonnancement...................................................... .............................................. ................................... .................. ............ .......... .... .3 IV.2 IV.2 Définition des taches................................................... taches............................ .............................................. .............................................. ........................................ ....................... .......... .3 IV.3 IV.3 Définition des contraintes.............................. contraintes..................................................... ............................................. ...................................... ...................... ............ ............ ........... ..... .3 IV.4 Chemin critique.................................................................................................................................. .4 IV.5 IV.5 Mise en œuvre ............................................ ..................... .............................................. .............................................. .............................................. ....................................... .................... .4 V Algorithme................................................................................................................................................... .5 V.1 Démarche et problèmes rencontrés............................... rencontrés...................................................... .............................................. ............................................ ......................... .... .5 V.1.i Première approche du sujet................................................. sujet........................................................................ .............................................. ...................................... ...................... ....... .5 V.1.ii Première démarche.......................................... démarche................................................................. .............................................. .............................................. ......................................... .................. .5 V.1.iii Un problème d'ordre................................ d'ordre....................................................... .............................................. ............................................. ................................................ .......................... .5 V.1.iv Deuxième démarche.......................................... démarche................................................................. .............................................. .............................................. ..................................... ................ .7 V.1.v Problème de la récursivité sous Matlab........................................................ Matlab............................................................................... .......................................... .....................7 V.1.vi Démarche itérative............................................ itérative................................................................... .............................................. ............................................. ....................................... ...................7 V.2 Algorithmes.......................................................................................................................................... .7 V.2.i Premier Algorithme ........................................... .................................................................. .............................................. .............................................................. ....................................... .7
a) Algorithme.................................................................................................................................................... Algorithme..........................................................................................................................................................7 b) Conclusion.................................................................... Conclusion...................................................................................................................................................... ....................................................................................8 V.2.ii Algorithme en récursif...................................... récursif............................................................. .............................................. .............................................. ........................................ ................. .8 a) Algorithme.................................................................................................................................................... Algorithme..........................................................................................................................................................8 V.2.iii Algorithme en e n itératif.......................................... itératif................................................................ ............................................. .......................................................... ................................... .10 a) Déclaration des matrices utilisées lors de l'algorithmique............................................................................ l'algorithmique........................................................................... .10 Déclaration de la matrice M1.......................................................................................................................... M1............................................................................................................................10 a) Déclaration de la matrice intermédiaire M2..................................................................................................11 M2..................................................................................................11 V.2.iv Algorithme en récursif.................................... récursif........................................................... .............................................. .............................................. ....................................... ................ .12 a) Algorithme................................................................................................. Algorithme................................................................................................................................................... .....................................................12 b) Conclusion.................................................................... Conclusion.................................................................................................................................................... ..................................................................................13 V.2.v Algorithme en itératif........................................... itératif.................................................................. .............................................. ................................................. .................................. ........ .13 a) Algorithme ................................................................................................................................................. .......................................................................................................................................................14 b) Résultat MATRICE FINALE il nous reste plus ka faire la difference entre duree o plus tard et duree o plus tot. Pour chaque resultat nul, la tache appartien o chemin critique. Sinon, le resultat obtenu nous donne la marge associée a chke tache........ tache....... .16 c) Conclusion et commentaires.................................................... commentaires......................................................................................................................... .......................................................................16 V.2.vi Exemple pour une installation industrielle....................................... industrielle.............................................................. ............................................. ............................ ........17 a) Tableau Tableau des tâches............................................................................................................. tâches............................................................................................................................ ........................ ............ .....17 b) Résultat obtenu avec Matlab......................................................................................................................... Matlab........................................................................................................................ .17
VI Applications sur l'ordonnancement : Le Viaduc de Millau........................................................................ .18 VI.1 Exemples de tâches.................................................. tâches........................... .............................................. .............................................. .............................................. .......................... ... .18 VI.2 Intérêt de l'ordonnancement ............................................ ..................... .............................................. .............................................. ..................................... .................. .19 VI.3 Deux types d'ordonnancement.................................. d'ordonnancement......................................................... .............................................. ....................................... ...................... ......... ... .19 VII Conclusion ............................................................................................................................................ .19 VIII Annexes................................................................................................................................................. .20 VIII.1 Algorithme présence..................................................................................................................... .20 VIII.2 Fichiers Matlab............................................................................................................................. .20
Projet: Ordonnancement
1
IAbstract
II Remerciements
Nous tenons à remercier M. EL KABOUCHI , notre tuteur, pour sa disponibilité, et ses conseils. Nous souhaitons également remercier M. PUJOS pour les renseignements qu'il a pu nous apporter.
Projet: Ordonnancement
2
III Introduction
L'objectif de ce projet est de déterminer le chemin critique en ordonnancement ainsi que les marges associées à chaque tâches. En effet, l'ordonnancement est une technique qui permet de gérer l'ordre des tâches dans lequel elles doivent être effectuées afin de ne pas perturber l'échéance d'un projet. Ce dossier étudiera dans un premier temps la théorie de l'ordonnancement. Dans une seconde partie il abordera les questions de l'algorithmique en rapport au problème de l'ordonnancement, afin de déterminer le chemin critique. Puis il évoquera le développement d'une application sous le logiciel Matlab pouvant traiter tous les types de problèmes d'ordonnancement. Une interprétation d'un exemple simple fournit comme directive pour le projet sera donnée, puis le traitement d' un exemple plus complexes sera abordé, ce qui permettra de prendre plus de recul sur l'ordonnancement et sa relation au programme Matlab. Pour finir le dossier abordera une application de l'ordonnancement dans le milieu industriel. IVPrésentation générale
IV.1 Définition de l'ordonnancement Un problème d'ordonnancement est un sous problème de planification. Ce problème permet de réaliser dans le temps, la réalisation des tâches compte tenu des contraintes temporelles (délais et contraintes d'enchaînement). La théorie d'ordonnancement s'intéresse au calcul des dates d'exécution optimales des tâches. De manière plus précise, on parle d'ordonnancement lorsqu'on fixe la date de début et de fin de chacune des tâches. IV.2 Définition des taches Une tâches est une entité élémentaire de travail localisée dans le temps par une date de début t i et/ou de fin c i , dont la réalisation nécessite une durée p i ci t i Lorsque les taches ne sont soumises à aucune contrainte de cohérence technologique (par exemple les contraintes d'enchainement), elles sont dites indépendantes. A chaque tache, on peut associer deux dates différentes : la date au plus tôt et la date au plus tard. La date au plus tôt est la date à laquelle la tacha pourra être commencée au plus tôt, en tenant compte du temps nécessaire à l'exécution des taches précédentes. Et la date au plus tard est la date à laquelle la tache doit être commencée à tout prix si l'on ne veut pas retarder l'ensemble du projet. =
−
IV.3 Définition des contraintes Les contraintes expriment des restrictions sur les valeurs que peuvent prendre simultanément les variables de décision. On distingue deux types de contraintes temporelles : Les contraintes de temps alloué, qui sont issues d'impératifs de gestion et et dépendantes des dates limites des tâches ou de la durée totale du projet. •
Projet: Ordonnancement
3
•Les
contraintes de cohérence technologique, appelées contraintes d'antériorité, qui décrivent l'ordre relatif qui doit être respecté entre les tâches.
IV.4 Chemin critique Le chemin critique détermine la durée minimale du projet. On dit qu'une tache de A vers B est critique si la différence entre la date au plus tard de B et la date au plus tôt de A est égale à la durée de tâche à accomplir. Les tâches critiques, ainsi déterminées, définissent le chemin critique, qui est le chemin sur lequel aucune tâche ne doit avoir de retard, pour ne pas retarder l'ensemble du projet. IV.5 Mise en œuvre On attache une importance à mettre en évidence les liaisons qui existent entre ces différentes tâches et à définir le chemin critique. Le but est de trouver la meilleure organisation possible, pour réaliser un projet dans les meilleurs délais. Pour construire un graphe d'ordonnancement, on procède de la manière suivante : Dans une premier temps, il faut créer un tableau contenant deux colonnes. La première colonne contient le nom des taches et dans la deuxième colonne on inscrit les contraintes c'est à dire les taches qui doivent être effectuées avant la tache considérée. Exemple : On doit exécuter sept taches a,b,c,d,e,f ,g soumises aux contraintes de succession rapportées dans le tableau ci-dessous : Tâches a b c d e f g
Contraintes b achevée b achevée a et d achevées c,e et f achevées
Puis on traduit le tableau sous forme de graphe en liant les taches qui se suivent. Pour effectuer une tache, il faut que les contraintes soient achevées. Donc dans notre graphe, toutes les tâches dans la colonne contrainte seront suivies des tâches qu'elles contraignent.
Projet: Ordonnancement
4
Prenons l'exemple pour comprendre: La tache b est dans la colonne contrainte. Elle contraint les taches d et e. Et donc dans le graphe la tache b sera suivie des taches d et e. Puis on fait de même pour toutes les taches, et ainsi notre graphe d'exemple se construit : a
f d
Départ
b e c
g
Fin
Illustration 1: Graphe des tâches de l'exemple VAlgorithme
V.1 Démarche et problèmes rencontrés Première approche du sujet
A la lecture du sujet, nous avons fait un rapprochement avec le cours de Monsieur Raynal, Professeur de Management à l'ISMANS. En effet, lors de ce cours nous avions pu voir l'une des méthodes d'ordonnancement, qui était le PERT ( Programm Evaluation and Review Technique - technique d'ordonnancement et de contrôle des programmes). Première démarche
A l'aide de cette méthode, nous avons mis au point un algorithme permettant de calculer: •
le jour au plus tôt où la tâche peut être effectuée,
•
le jour au plus tard où une tâche peut être effectuée,
afin de pouvoir déduire la marge associée à chaque tâche, c'est à dire la durée maximale de retard possible sur une tâche. Cette durée est la différence entre le jour au plus tôt et le jour au plus tard où la tâche peut être effectuée, sans que cela perturbe la durée totale du projet. Un problème d'ordre
Mais nous avons eu un problème lors de la réalisation de l'algorithme du jour au plus tard, car nous nous sommes rendus compte que si les tâches n'étaient pas ordonnées, l'algorithme ne fonctionnait pas. Après une recherche sur internet,nous avons envisagé d'effectuer un algorithme pour ordonner les tâches par niveau : Méthode des niveaux (http://www.logistiqueconseil.org/Fiches/Logistique/Pert.pdf ) Cette méthode permet de distinguer les différents niveaux qui apparaissent dans le problème d'ordonnancement. On effectue des manipulations sur les lignes d'un tableau, et les niveaux du problème d'ordonnancement se distinguent. A l'aide de cette méthode, on peut en déduire le graphe des niveaux suivant pour notre exemple. Projet: Ordonnancement
5
a
f d
Départ
b e c Niveau 1
g Niveau 2
Niveau 3
Fin
Niveau 4
Illustration 2: Graphe des tâches de l'exemple avec les niveaux
Après la compréhension de la méthode des niveaux, nous avons réalisé la matrice suivante pour l'exemple : Construction de la matrice :
A
=
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
1
0
0
0
0
0
0
1
0
0
0
0
0
1
0
0
1
0
0
0
0
0
1
0
1
1
0
Les lignes correspondent aux tâches à réaliser, et les colonnes aux tâches réalisées, sachant que le nombre de lignes et de colonnes correspond aux nombres tâches à ordonnancer. Pour expliquer la construction de la matrice, prenons l'exemple : a
a b c A= d e f g
b c
0 0 0 0 0 1 0
0 0 0 1 1 0 0
0 0 0 0 0 0 1
d
0 0 0 0 0 1 0
e
0 0 0 0 0 0 1
f
g
0 0 0 0 0 0 1
0 0 0 0 0 0 0
f g
a et d achevées c,e et f achevées
La tâche f est à réaliser, pour cela il faut que les tâches a et d soient réalisées. Ainsi dans la matrice a (6,1) et a(6,4) prennent la valeur 1. De même pour les autres tâches.
Projet: Ordonnancement
6
Deuxième démarche
Mais suite à la première réunion de tutorat, nous avons été orienté vers une nouvelle piste où ordonner les tâches n'était pas nécessaire. Nous nous sommes alors dirigés vers la construction d' une nouvelle matrice M2, elle permet d' intégrer directement les durées associées pour effectuer les tâches. Ce qui a permis cette fois-ci d'aboutir à des algorithmes permettant de calculer le jour au plus tôt et le jour au plus tard de chaque tâche. Problème de la récursivité sous Matlab
Cependant, ces algorithmes mis au point, utilisent des principes de récursivité, or le logiciel MATLAB pose un problème au bout de 500 récursivités. Ceci peut entrainer des erreurs dans le cas des problèmes d'ordonnancement comportant de nombreuses tâches couplées entre elles (majorité des cas industriels). Lors de nos réunion de tutorat, nous avons été rédigé vers une méthode itérative pour éviter ce problème de saturation. Démarche itérative
Nous nous sommes donc dirigés vers une méthode itérative. Dans cette méthode, nous utilisons de plusieurs matrices pour résoudre le problème d'ordonnancement. •
•
M1 est la matrice qui représente le tableau du problème. C'est l'utilisateur en répondant à chaque questions posées par le programme qui va la remplir. M2 est la matrice qui définie les durées des tâches.
Pour déterminer le jour au plus tard, on procède de la manière suivante : Après avoir écrit la matrice M2, on écrit ensuite la matrice M3, dans laquelle on calcule le maximum des colonnes pour obtenir le résultat, c’est notre matrice de sortie. Puis nous utilisons une matrice qui sert de stockage du chemin que l’on est en train de parcourir, c'est la matrice M4. Elle permet de pouvoir continuer le chemin. Cette matrice permet d’avoir une démarche de proche en proche pour obtenir le résultat. Et enfin une dernière matrice, M5, sert à la mise en place d’une condition d’arrêt sur chaque nœud, c'est-àdire que tant que les chemins qui aboutissent à un même nœud ne sont pas entièrement faits, on ne calcule pas le jour max de ce nœud. Et de manière analogue, on construira les matrices M6, M7 et M8 pour déterminer le jour au plus tard. V.2Algorithmes Premier Algorithme a) Algorithme
Ordonnancement ( T: TABLEAU[0,N][1,6]) % N nombre de tâches Pré-condition: % a définir Post-condition: % a définir % début de l'algorithme permettant de définir le jour le plus court de chaque tâche.
Projet: Ordonnancement
7
Réalisation: i←N Tant que i←N Répéter Si T(i,3)=0 Alors T(i,4)←T(i,2) Sinon T(i,4)←T(i,2) + MAX(T(i,3)) % on prend la valeur maximale des contraintes présentes à la ligne i et la colonne 3 du tableau d'entrée Fin Si i←i+1 Fin Tant que => Utilisation du MAX MAX ( TABLEAU[0,N][1,6], … ): ENTIER k←2 j←1 r : premier charactere % ça sera le résultat du MAX m←Nombre_caractère(T(i,3)) Tant que k ≤ m Répéter Si disp(ch(j))≥ disp(ch(k)) % « disp »correspond à la fonction qui assimile un caractère à un nombre. Alors k←k+1 et r←disp(ch(j)) Sinon j←j+1 Fin Si Fin tant que b) Conclusion
Ce premier algorithme fonctionne seulement si les tâches sont ordonnées, c'est à dire si elles sont mis dans l'ordre chronologique dès le départ. Algorithme en récursif a) Algorithme
DUREE_MAX( B[j,k]):ENTIER % On fixe k et on fait varier les ligne et on regarde quand M(j,k) est différent de 0. Si c'est le cas on prend cette valeur et on l'additionne à la durée max B[x,j-1] en fixant j (on regarde sur la colonne j-1) et en faisant varier les lignes x. A:M1 ? B: M2 ? C: M3 ? Précondition: B remplit Post-condition: Déclaration de variables: Projet: Ordonnancement
C: TABLEAU [ENTIER] [1, N+1] [1, N]
8
j: ENTIER k: ENTIER Réalisation: j←1 Si k=1 Alors résultat ←0 Sinon Tant que J ≤ N+1 Répéter
Fin Répéter Fin Si
Si B[j;k] =0 Alors C[j,k]←0 Sinon C[j,k] ←B[j;k]+DUREE_MAX( B[j,k-1]) Fin Si j←j+1
A[k+1;4]MAX(C[i;k]) % on prend la valeur maximale de la colonne k que l'on fait variée
JOUR_MAXI ( M1: TABLEAU [ENTIER] [1, N+1] [1, 6]: ENTIER; M2: TABLEAU [ENTIER] [1, N+1] [1, N]: ENTIER): M1: TABLEAU [ENTIER] [1, N] [1, 6]: ENTIER Précondition: M2 remplit Post-condition: le résulta de la ligne i et de la colonne 4 contient la durée minimal où la tache i peut être effectué. Déclaration de variables:
k: ENTIER
Réalisation: k←1 Tant que k ≤ N Répéter M1[k+1;4]←DUREE_MAX(M3[i;k]) % on calcule la durée maximale sur la colonne k (qui correspond à regarder le jour minimal de la tâche k dans M2 ou k+1 dans M1 (même tâche)
Fin Répéter
k←k+1
Fin JOUR_MAXI b) Conclusion
Nous n'avons pas continué avec cette méthode, car le logiciel Matlab aurait bloqué au bout de 500 récursivités, et nous aurions été limité à 25 tâches.
Projet: Ordonnancement
9
Algorithme en itératif a) Déclaration des matrices utilisées lors de l'algorithmique
Pour ce programme nous avons besoin de définir des matrices: Déclaration de la matrice M1
N=input ('Entrer le nombre de taches:') % N reçoit le nombre de tâches M=zeros(N+1,1) % M matrice remplie de 0 de N+1 ligne et de une colonne Pour i = 2 jusqu'à i =N+1 M(i,1) = input (['Entrer le nom de la tache ' num2str(i-1) ':']) % M (i,1) représente le coefficient de la i ème ligne, première colonne de la matrice M % La première colonne de la matrice M1 est remplie par le nom de chaque tâche.
M(i,2) = input (['Entrer la durée de la tache ' num2str(i-1) ':']) % M (i,2) représente le coefficient de la i ème ligne, deuxième colonne de la matrice M % La seconde colonne de la matrice M1 est remplie par la durée associée à chaque tâche.
k=input(' Combien avez-vous de contraintes:') % k correspond au nombre de tâches à effectuer avant la tâche correspondante à la ligne i.
Si k≥1 Pour j =1 jusqu'à j=k M(i,j+2) = input(['Entrer la tache à effectuer avant la tache ' num2str(i-1) ':']) % prend le nom de la tâche à effectuer avant la tâche correspondante a la ligne i
Fin Sinon Si k ≤ à 1 M(i,3)=0 % si il n'y à pas de tâches à effectuer avant la tâche correspondante à la ligne i, le nom de la tâche à effectuer avant est égal à zéro.
Fin si
Fin Si
Fin Pour notre exemple: M1
M1=
0 1 2 3 4 5 6 7
0 6 3 6 2 4 3 1
0 0 0 0 2 2 1 3
0 0 0 0 0 0 4 5
Projet: Ordonnancement
0 0 0 0 0 0 0 6
10
Déclaration de la matrice intermédiaire M2 M2=zeros(N+1,N) % Matrice de 0 de N+1 lignes et N colonnes. m= size(M,2) % Donne le nombre de colonne de la matrice. p←1 q←1 Tant que p ≤ à N Si p=1
Sinon
Tant que q ≤ à N-1 Si M(p,1)=M(q+1,3) M2(p,q)=M(q+1,2) Fin Si q ← q+1 Fin Tant que q←1 Tant que q ≤ N Pour u=3 jusqu'à u=m Si M(p,1) = M(q+1,u) M2(p,q) = M(q+1,2) Fin Si Fin q←q+1 Fin Tant que q←1
Fin Si p←p+1 Fin Pour notre exemple: M2
M2=
6 0 0 0 0 0 0 0
3 0 0 0 0 0 0 0
6 0 0 0 0 0 0 0
0 0 2 0 0 0 0 0
Projet: Ordonnancement
0 0 4 0 0 0 0 0
0 3 0 0 3 0 0 0
0 0 0 1 0 1 1 0
11
Nous avons également besoin de définir dM3, qui est de la même dimension que M2, est la matrice finale, sur laquelle on fait le maximum des colonnes. M3 pour l'exemple:
M3=
6 0 0 0 0 0 0 0
3 0 0 0 0 0 0 0
6 0 0 0 0 0 0 0
0 0 2 0 0 0 0 0
0 0 4 0 0 0 0 0
0 3 0 0 3 0 0 0
0 0 0 1 0 1 1 0
Déclaration de la matrice M4: M4[N+1,N] est la matrice qui stocke le jour maximale de chaque chemin calculé. D'autre part elle permet de se rappeler quel chemin nous faisons.
M4initial
=
•
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
de M5
M5[2,N] est la matrice qui pose la condition sur chaque noeud. C'est a dire qu'elle permet le franchissement d'un Projet: Ordonnancement
12
noeud, une fois que tous les chemins la joignant sont calculé. a) Algorithme
REMPLISSAGE_M4(M2,M4):M4 Précondition: Post-condition: Déclaration d e variables: j: ENTIER Réalisation: j←1 Tant que j≤N Répeter
Si M2[1;j]≠0 Alors M4[1,j]←M2[1;j] Fin Si
j←j+1 Fin Répéter Fin REMPLISSAGE_M4 REMPLISSAGE_M5(M2,M5):M5 Précondition: Post-condition: Déclaration de variables: v: ENTIER w: ENTIER Réalisation: v←1 w←1 Tant que v ≤ N Répéter Tant que w ≤ N Répéter Si M2[w,v]≠0 Alors M5[1;v]←M5[1;v]+1 Fin Si w←w+1 Fin répéter v←v+1 Fin répéter FIN REMPLISSAGE_M5 exemple de remplissage M5 : Chaque valeur correspond au nombre de chemin arrivant sur une tache. C'est a dire, il y a un chemin qui arrive sur a, 1 sur b,..., 2 sur f, 3 sur g. ¿
M5 =
1 1 1 1 1 2 3 0 0 0 0 0 0 0
Projet: Ordonnancement
13
JOUR_MAX(M2,M3,M4,M5): M3 Précondition: Post-condition: Décla ration de variables: p: ENTIER k: ENTIER m: ENTIER Réalisation: p←1 k←1 m←1 Tant que p ≤ N+1%on est sur la ligne p de M4 Répéter Tant que k ≤ N % on est sur la colne k de M4 Répéter Si M4[p;k] ≠ 0%on regarde les valeur non nulles de M4 a la ligne p et la colone k Alors Tant que m ≤ N Répéter si M3[k+1;m] ≠ 0 Alors M3[k+1,m]←M3[k+1;m]+M4[p;k] % la matrice M3 prend la valeur de son chemin, qui etait stocké dans M3, plus celle de M4 qui correspond au jour Max %des taches antecedantes. Et M5[2,m]←M5[2;m]+1 % on increment la colonne equivalente dans M5, signifiant qu'un chemin supplementaire a ete calculé. Et Si M5[1,m] = M5[2,m] % on regarde si tous les chemins precedants la tache ont ete calculé. alors M4[p+1,m]←max(M3[1...n+1;m]) % on active un nouveau chemin a calculer dans M4. Ce chemin prend le jour max de la tache antecedante. Fin Si Fin Si m←m+1 Fin Répéter M←1 Fin Si k←k+1 Fin Répéter p←p+1 k←1 Fin Répéter FIN JOUR_MAX
