Vous êtes sur la page 1sur 22

Ressource Algorithme. Leveling c. 0.

20090312a
Ce document est actuellement un projet alpha. Il est destin tre beaucoup chang, mme compltement
rcrite si ncessaire. L'algorithme tel que dcrit encore manque quelques fonctionnalits encore. Il est modifi
ainsi que les tests de rgression qui apporte de nouvelles usecases. Il est encore rendu public de donner
des ides et dj obtenir des commentaires. Actuellement 24 usecases de rgression sont couverts
avec succs par cet algorithme.
Contenu
[ Hide ]

1 Objectif

2 Donnes d' entre

3 Les donnes de sortie

4 conventions

5 Vue d' ensemble

5.1 Principe de base

5.2 Computing dynamiquement l'importance des tches

5.3 Rorganisation des tches et de se souvenir: l'arbre des chemins

5.4 Plusieurs faons d'attribuer une tche ses ressources disponibles

5,5 architecture et les composants Algorithme

5.6 Rsum Algorithme

6 Explication dtaille

6.1 Premires explications, types de donnes

6.1.1 Identifier la faon dont une tche est assigne ses ressources disponibles

6.1.2 consquences d'enregistrement de l'affectation d'une tche

6.1.3 tches Rorganiser, remplaant branches, chemins de mmoire

6.1.4 La structure principale stockant la faon dont les tches sont attribues aux ressources

6.2 Les noms de mthode regroups par des acteurs

7 Les mthodes d'algorithme dtailles

7.1 Solution Manager

7.2 affectation des tches Gestionnaire

7.3 Gestionnaire d'importance

7.4 Chemins Gestionnaire

8 Les implmentations actuelles

8.1 Ruby

8.1.1 informations d'accs et tlchargement

9 Remarques

10 ides pour l' amlioration

11 contacts

[ Modifier ]Objectif
Le but de cet article est de prsenter un algorithme libre de mise niveau des ressources qui peuvent tre mis en
uvre facilement.
Il donnera des structures de donnes simples et des fonctions simples qui peuvent tre presque copis / colls
courir. On suppose que le lecteur possde dj une connaissance de base de la gestion de projet, ce qui signifie qu'il
sait sur le problme de la mise niveau des ressources l'intrieur d'un projet.
[ Modifier ] Lesdonnes

d'entre

Voici les notions l'algorithme traite en entre:


Ressources: ils contiennent les attributs suivants:

Calendrier des disponibilits: il est un calendrier contenant un certain nombre d'heures de travail pour
chaque jour depuis le dbut jusqu' la fin du projet.
Tches: ils contiennent les attributs suivants:

Priorit: il mesure combien l'importance de cette tche est. Il est un nombre entier (plus le plus
important).

Dimensionnement: il mesure le nombre d'heures de travail ncessaires pour accomplir la tche.

Liste des successeurs: une liste d'autres tches qui ne peuvent pas commencer moins celle-ci est
termine.

Liste des ressources assignables: une liste de rfrences aux ressources qui peuvent tre affectes

cette tche. Pour chaque ressource assignable, il est possible d'indiquer un montant maximal d'heures de
travail pour cette association.
Diffrentes faons d'attribuer un ensemble de ressources une tche (l'algorithme peut essayer plusieurs

tentatives et choisir le meilleur). Chaque voie peut tre rgl compte tenu de certains paramtres humains. Les
paramtres sont mdit avec des coefficients:

Il peut tre prfrable d'affecter seulement 1 ressource une tche si possible mme si la tche est

un peu retard.

Il peut tre prfrable de ne pas modifier les tches assignes d'une ressource trop souvent.

Il peut tre prfrable pour une tche de rutiliser les mmes ressources que ses prdcesseurs.

Les plus de ressources travaillent sur une tche, plus l'effort qu'il faudra pour terminer la tche en
raison de contraintes de la communication humaine.

[ Modifier ] Lesdonnes

de sortie

Voici les informations de l'algorithme donne en sortie:


Pour chaque ressource:

Calendrier des tches travailler sur: pour chaque jour, un ensemble de tches et de leurs heures de

travail correspondant.
[ Modifier ]Conventions
Les conventions de dnomination suivantes sont valables pour les explications suivantes:

Ri reprsente une ressource (numro i).

Ti reprsente une tche (nombre i).

[A, B, C] reprsente une liste contenant des lments A, B et C.

... Reprsente une squence (pourrait tre undefined) des articles. Peut tre utilis dans les listes ([A, ..., Z]).

carte <TypeA, TypeB> reprsente un type de carte, dont les cls sont de type TypeA et les valeurs de type
TypeB.

liste <TypeA> reprsente un type de liste, le stockage des articles de type TypeA.

[NAMEA: TypeA, titreB: TypeB, ...] reprsente une liste d'lments numriques finis qui ont un nom donn et
un type donn. Cela peut tre considr comme une structure de donnes d'enregistrement. Les valeurs d'une telle
structure peuvent tre abrges [ValueA, ValueB], tant donn que ValueA est affecte l'attribut NAMEA, et ainsi
de suite.

T.Priority reprsente la priorit de la tche T.

T.Sizing reprsente le nombre d'heures ncessaires pour complter T.

T.MaximalResourceAllocation [R] reprsente le nombre maximal d'heures de la ressource R peut travailler sur
la tche T.

T.Predecessors reprsente la liste des prdcesseurs de T.

T.SharingResourcesTasksID est un identifiant qui est le mme pour toutes les tches qui peuvent partager au
moins 1 ressource. Elle peut tre considre comme un identifiant d'une partition des tches. Il identifie toutes les
tches qui pourraient influencer les uns des autres en raison des affectations de ressources.

Map.keys reprsente la liste contenant toutes les cls d'une carte.

La granularit des exemples dans ce document est de jours. Cependant, l'algorithme prend en compte la cession
heures. Ce choix dans le document a t faite pour des raisons de clart.
[ Modifier ]Prsentation
[ Modifier ]Principe

de base

L'ide principale de l'algorithme est de considrer, pour chaque tche, les ressources disponibles qui pourraient
travailler pour elle. Par consquent, un calendrier de la disponibilit des ressources pour chaque tche est construit.
Ensuite, les tches sont assignes 1 par 1, du plus important au moins important, leurs ressources
disponibles. Chaque fois qu'une tche est assigne, les ressources disponibles des autres tches sont mises jour en
consquence.

[ Modifier ]Computing

dynamiquement l'importance des tches

L'efficacit de l'algorithme rside dans l'ordonnancement des tches; qui est le calcul de l'importance des tches. Il est
obligatoire que les plus importants (les tches hautement prioritaires) sont affects leurs ressources avant les autres,
si possible.
Toutefois, il est possible que les tches de faible priorit doivent tre attribus avant les hautement prioritaires, sinon ils
retarderaient plus grands encore prioritaires en raison de dpendances. Ces retards peuvent tre vus que lorsque nous
attribuons des tches loin dans l'avenir, et peuvent difficilement tre considrs lors de l'attribution premiers.
Par consquent, le calcul de l'importance d'une tche ncessite d'essayer toutes les affectations possibles des tches
aux ressources. Il est impossible en raison de contraintes de performance.
Ceci est la raison pour laquelle l'algorithme fait une premire sorte de tches, en fonction de l'importance simplement
calcul (en utilisant des priorits et des chemins critiques). Il est alors possible que cet ordre ne sont pas toujours
optimale. Il peut tre compris lorsque l'algorithme se rend compte que la tche est retarde, mais aurait pu tre affect
aux ressources dans le pass qui ont dj t affect une autre tche. Par consquent, l'ordre des tches est modifi
dynamiquement en fonction de ces rsultats, et puis il essaie nouveau de les affecter dans ce nouvel
ordre. L'algorithme se souvient de chaque sorte qui a t essay et puis peut choisir parmi les chemins prvenus ou les
chemins les moins chers.
[ Modifier ] lestches

de Rorganiser et se souvenir: les chemins arbre

L'ide principale tant que nous devons trouver le meilleur type possible des tches, l'algorithme doit garder une trace
de tous les chemins essay. Ceci induit naturellement la cration d'un arbre de tous les chemins essay dj rencontrs
dans l'algorithme.
Chaque nud de cet arbre reprsente une tche assigne ses ressources d'une certaine faon. Une branche de cet
arbre reprsente une sorte donne des tches, et associ chaque noeud sont les consquences d'une telle cession (si
elle retarde tort d'autres tches ou non).
Ensuite, l'algorithme peut tre interprt comme trouver le meilleur chemin entre cet arbre, qui est celle qui minimise les
consquences.
Voici un exemple d'une cession qui doit rorganiser les tches.

[ Modifier ]Plusieurs

faons d'assigner une tche ses ressources disponibles

Chaque fois qu'une tche est assigne certaines de ses ressources, plusieurs tentatives sont faites pour le faire
diffremment, et alors la meilleure solution est maintenue. Chaque tentative est enregistre, avec les consquences
qu'elle a en termes de retards de tches, et il est alors possible de choisir entre les diffrentes faons dont l'un est le
meilleur.
[ Modifier ]architecture

et les composants Algorithme

Afin de mieux comprendre l'algorithme, quelques acteurs peuvent tre dfinis.

Algorithme point d'entre reprsente la principale mthode de l'algorithme, la manipulation des entres et

sorties comme dcrit prcdemment.


Le gestionnaire de l'importance gre l'ordre des tches et leur importance. Il

cre l'ordre initial des tches et

met jour l'importance des tches.


Le gestionnaire de solution essaie d'attribuer une liste trie des tches leurs ressources. Son but est de

trouver diffrentes faons de les affecter et comparer plusieurs solutions pour obtenir le meilleur.

Le gestionnaire de la rpartition des tches tente d'assigner une seule tche ses ressources. Il met ensuite
jour toutes les informations pertinentes qui pourraient tre touchs sur d'autres tches. Enfin, il vrifie si d'autres
tches peuvent accepter le rendez-vous.

Les chemins gestionnaire stocke tous les chemins essay (les trie de tches) l'algorithme obtenu, et pour
chacun d'entre eux stocke les consquences de ce chemin eu sur les tches. Ensuite, ce gestionnaire donne la
possibilit de rcuprer le meilleur chemin possible en fonction de cette information.

[ Modifier ]Rsum

Algorithme

L'algorithme peut tre rsum ainsi:


1. Calculer les dates de dbut minimales de chaque tche, tant donn que toutes les ressources disponibles
pourraient travailler pour eux, et en prenant en considration les dpendances.

2. Trier les tches par ordre d' importance simple. L'importance est calcule de manire rcursive que la valeur
maximale entre la priorit de la tche et l'importance de tous ses successeurs directs (successeurs qui pourrait
commencer juste aprs l'achvement de cette tche)

3. Appel d' une mthode rcursive qui tente d'assigner des tches 1 par 1:
3.1. Essayez plusieurs faons d'attribuer la tche ses ressources disponibles. Pour chaque voie:

3.1.1. Calculer les consquences de cette cession dans les tches suivantes non encore attribus (calculer
leur nouvel horaire minimal, selon de la disponibilit et les tches des nouvelles ressources des
dpendances).
3.1.2. Terminez la mmoire de chemins essay avec ces informations.
3.1.3. Si l'affectation ne se dplace pas des tches (leur minimum de date de fin) qui sont plus importants que
ceux dj attribus, appelez rcursivement la mthode qui assignera la tche suivante dans la liste. Rappelez
- vous toutes les solutions possibles renvoyes par cet appel, ainsi que des sentiers meilleurs possibles , il
peut proposer en cas de impossibilities.Once toutes les itrations ont t essays, soit renvoyer les solutions
possibles, ou trouver des chemins meilleurs possibles si aucune solution n'a t trouve.
3.2. S'il y a une meilleure voie qui peut tre prise ce stade, faire en revenant aux itrations avec le nouveau
chemin.
4. Choisir la meilleure solution parmi tous ceux mmoriss.
[ Modifier ]Explication
[ Modifier ]Premires

dtaille

explications, les types de

donnes
[ Modifier ]Identifier la faon dont une tche est

assigne ses ressources disponibles


Il y a un type de donnes identifiant une tche assigne d' une
certaine manire ses ressources (il y a une manire itrative
d'assigner des tches aux ressources, par exemple d' abord
essayer d'affecter autant de ressources que possible pour
mettre fin plus tt, puis essayez d'attribuer un ensemble
minimal de des ressources la tche afin d' viter
la complexit de communication , ...). Chaque moyen
d'assigner une tche est identifie par un numro
d'itration. Par consquent , il est possible de revenir une
certaine faon de la rpartition des tches en se souvenant
de cet identifiant. Numros de Iteration commencent partir
de 0 et 1 augmentent de 1 pour chaque tche. Ce type de
donnes est appeleAssignedTaskID_Type . Une faon
d'assigner une tche ses ressources disponibles est
enregistre dans une autre structure, stocker des heures de
travail affectes par ressource, par
jour: TaskAssignmentSolution_Type .
[ Modifier ]consquences d'enregistrement de

l'affectation d'une tche


Quand une tche est assigne ses ressources, il modifiera
les disponibilits des ressources pour d' autres tches, et peut
- tre changer l'horaire de ces tches. Cela peut tre inoffensif,
mais il peut aussi tre pas rentable pour la solution finale.Par
consquent , il est ncessaire de se rappeler les
consquences de chaque mission sur les autres tches. Sur
la base de ces informations, il sera possible de trouver
intelligemment une meilleure voie possible d'utiliser. Le
typeShiftedTaskConsequences_Type a t faite cette fin. Il
stocke un arbre de tches dont la date fin minimale ont t

dcales d'une cession. Il est un arbre parce que ces


changements se produisent de manire rcursive: l'affectation
de T1 dplace T2 ( en prenant ses ressources), puis T2 sera
galement dplacer T3 parce T3 dpend de T2.
[ Modifier ] lestches de rapprovisionnement,

le remplacement des branches, des chemins


de mmoire
Il est ncessaire parfois d'effectuer une rorganisation des
tches attribuer. Quand nous essayons d'assigner une
squence de tches des ressources, il est possible que nous
ralisons cette squence est pas optimale ( ce qui signifie
l'ordre original de la liste des tches peut tre optimise). Cette
optimisation se fait en dplaant vers le bas certaines tches ci
- dessous d' autres, donc rsultant en une nouvelle tche
ordonner que nous l' esprons, conduira une meilleure
solution ,une fois les tches sont assignes aux
ressources. Une branche de tches est reprsent par le
type Branch_Type .
Chaque ordre diffrent des tches peut tre considr comme
un chemin dans l'arbre de toutes les possibilits de l'affectation
de tches ses ressources. Chaque nud de cet arbre est
identifi la tche et la faon dont il a t affect ses
ressources (le nombre d'itrations). Pour mieux trouver
des chemins optimiss, il est ncessaire pour stocker chaque
chemin essay, et la raison pour laquelle certains d'entre eux
ont t considrs comme non optimis. Par consquent,
l'algorithme se souvient de l'ordre des tches et des numros
d'itration ainsi que l'importance de la tche quand il a t
affect, et la priorit maximale des tches dcale en raison
de cette affectation. Ceci est fait dans une structure
arborescente, dont les nuds reprsentent une tche
assigne ses ressources. Dans cet arbre, T2 enfant de T1
signifie que T1 a t affect d' abord, puis T2. Pour
reprsenter cet arbre, le type PathNode_Type a t cr.
Par

consquent , nous pouvons facilement se rappeler quel


chemin a dj t essay et n'a pas fonctionn en raison de
lapriorit des tches changent.
[ Modifier ]La structure principale stockant la faon

dont les tches sont attribues aux ressources


L'algorithme utilise une structure de donnes spciale qui
reprsente une configuration des tches assignes aux
ressources. Cette structure (appele AssignmentInfo_Type )
est une carte stockant des informations par tche. L'ide
derrire est d'imaginer des ressources comme des conteneurs
des efforts de tches. Au dbut de l'algorithme, les heures de
travail des ressources sont vides (non affect une tche), et
l'algorithme va assigner des tches peu peu libres heures
de ressources dans un calendrier. La AssignmentInfo_Type la
structure assure le suivi de l'volution des missions le long
de l'algorithme.
[ Modifier ] Lesnoms

des acteurs

de mthode regroups par

Suite l' architecture prcdente de l'algorithme, voici les


noms des mthodes qui seront utilises. Fichier:
AlgoMethods.png
[ Modifier ]Les

mthodes d'algorithme

dtailles
Principal
[ Modifier ]Solution

Manager

SolutionManager :: findAssignmentForTasksList
SolutionManager :: tryPossibleSolution
SolutionManager :: assignCompleteTask
[ Modifier ]Assignment

Task Manager

TaskAssignmentManager :: assignPossibleSolution
TaskAssignmentManager :: shiftChildrenTasks
TaskAssignmentManager :: shiftTaskMinimalDates
TaskAssignmentManager :: computeShiftedDateHours
TaskAssignmentManager ::
removeCountedHoursFromResourcesBuffers
TaskAssignmentManager :: removeResourcesFromOtherTasks
TaskAssignmentManager :: notifyMinimalEndDateChanged
[ Modifier ]Importance

gestionnaire

ImportanceManager :: populateImportances
ImportanceManager :: getSortedTasks
ImportanceManager :: updatePredecessorsImportances
ImportanceManager :: updateImportance
[ Modifier ] Leschemins

Gestionnaire

PathsManager :: findPossibleBetterPathForTask
PathsManager :: computeShiftedTasksList
PathsManager :: findUnknownPathReorderingShiftedTasks
PathsManager :: computeNewPathMovingTask
PathsManager :: validateUnknownPath
PathsManager :: reorderBranch
PathsManager :: findPossibleBetterPathAlreadyKnown
PathsManager ::
getBestPathAmongBestShiftedImportancePaths
PathsManager :: findSmallestShiftedConsequencesPaths
PathsManager :: completeTriedPath
[ Modifier ] Lesimplmentations
[ Modifier ]Ruby

actuelles

La premire mise en uvre de cet algorithme a t fait dans


le langage Ruby ( http://www.ruby-lang.org ). La rgression a
t faite dans cette langue, aussi.
[ Modifier ]Informations d'accs et tlchargement
Si vous voulez essayer l'algorithme et excuter les cas de
rgression avec elle, vous devrez:
1.

Obtenez Ruby si pas dj livr avec votre systme


d'exploitation

2.

Obtenez un client SVN si pas dj livr avec votre


systme d'exploitation

3.

Caisse du dpt SVN dans un rpertoire ( "svn


co https://resourcelevel.svn.sourceforge.net/svnroot/
resourcelevel ")

4.

Allez dans le rpertoire


"./resourcelevel/trunk/ruby/test".

5.

Tapez "ruby -I ../ lib -w run.rb". Cela excutera les


tests de rgression, et afficher le rsultat aprs une
sortie grande de dbogage. Les dernires lignes
devraient ressembler ceci:

.
Termin en 2,205 secondes.
24 tests, 24 assertions, 0 checs, 0
erreurs
En outre, vous pouvez parcourir l'arborescence SVN
ici: http://resourcelevel.svn.sourceforge.net/viewvc/resourcelev
el/trunk/ruby/
[ Modifier ]Remarques

Habituellement, ce n'est pas la philosophie de dfinir


dates de dbut / fin et les dures bases sur les efforts
prvus comme il est rarement raliste lorsqu'ils traitent
avec plusieurs ressources. Cependant, il est trs pratique
et raliste quand il y a seulement 1 ressources par tche,
et un facteur supplmentaire augmentant l'effort de tches
sur la base de la complexit des ressources a t prise en
compte (TODO). Cela donne cet algorithme plus de
crdibilit, mme pour de multiples ressources par tche.

La faon dont les tches sont assignes aux ressources


est pas exhaustive. Il existe de nombreuses diffrentes
faons de le faire. L'algorithme essaie chaque fois de
plusieurs faons, et valuera ensuite l'affectation finale
pour slectionner le meilleur.

La faon dont les tches sont tries est (ou devrait tre,
en cas de bugs) exhaustive. Cela signifie qu'une fois qu'il
a t dcid comment les tches sont attribues aux
ressources, l'algorithme doit trouver le genre optimale des
tches pour assurer ceux avec la plus grande priorit sera
accorde en premier.

Il y a 2 goulots d'tranglement identifis ce jour:

PathsManager :: findPossibleBetterPathForTask : Un
goulot d'tranglement de performances de haut
niveau. Si cette mthode donne de meilleurs
chemins d'une manire stupide, il peut soit entraner
les mmes problmes que ceux rencontrs
auparavant par des chemins prcdents, ou
entraner des chemins choisis au hasard et donc
jamais trouver une bonne solution facilement.

TaskAssignmentManager ::
notifyMinimalEndDateChanged : Un faible goulot
d'tranglement au niveau. Cette mthode est
appele trs souvent, comme pour chaque mission
d' essayer, il va modifier toutes les tches affectes
de manire rcursive due l' limination des
ressources ou les dpendances de tches.

[ Modifier ] Desides

pour l' amlioration

Dans l'algorithme, utilisez un cache pour SolutionManager


:: findAssignmentForTasksList appelle: il est possible qu'il
est appel plusieurs fois pour la mme iCurrentTasksList,
chacun d'entre eux partir de la mme date de dpart
avec les mmes ressources affectes dans la gamme de
date [date de dbut - > la fin du projet]. Dans ce cas,
le retour des solutions dj calcules. Ces rptitions
d'appels seraient dus au fait que nous essayons
de plusieurs diffrentes rpartition des ressources par
tche, et certains peuvent entraner les mmes appels (
valider si avant la mise en uvre).

Prendre d' autres contraintes en compte, que les dlais ou


les cots , par exemple. Les dlais seraient trs faciles
mettre en uvre, comme nous traitons dj avec
des dpendances nous ne pouvons pas se dplacer
dansTaskAssignmentManager ::
shiftChildrenTasks mthode. Il serait alors juste ncessiter
des modifications minimes TaskAssignmentManager ::
shiftChildrenTasks mthode.

Le calcul de l' effort ncessaire peut tre un peu


alatoire. Il est un moyen de modliser les erreurs
humaines dans dimensionnements ou les diverses
fluctuations que nous ne pouvons pas prvoir en raison
de facteurs externes qui entravent lajourne
la performance du jour des ressources. Ceci peut tre mis
en oeuvre dans l'itration de la mthode
principale SolutionManager ::
findAssignmentForTasksList . Il peut galement tre rgl
en utilisant des algorithmes gntiques (comme cela
semble tre la prochaine tendance dans le nivellement
du projet de gestion des ressources) pour modliser
les erreurs humaines qui pourraient tre un peu
prvisible. Le bon point est que nous avons juste besoin
de modifierSolutionManager ::
findAssignmentForTasksList mettre en uvre toute
stratgie que nous voulons ce sujet .

Nous pouvons ajouter la notion que les ressources ne


sont pas gaux devant la mme tche. Certains seront
plus efficaces que d' autres (connaissances techniques,
besoin de formation ...). Nous voulons toujours affecter
plusieurs ressources pour la tche (comme il peut tre
prfrable de former des ressources R1 et l' utiliser sur la
tche que d' utiliser directement R2 ressources sur elle,
mme sans formation - peut - tre parce que R2 doit
travailler sur une autre tche prioritaire dans le en mme
temps). Dans ce cas , nous pouvons changer l'effort
ncessaire d'une tche dans l'algorithme en fonction de la
ressource est affecte elle. Cela se fait aussi dans
l'itration principale de SolutionManager ::
findAssignmentForTasksList .

Nous pourrions slectionner un sous-ensemble de tches


niveau. 2 possibilits:

Si nous avons mis en place des chances


contraintes dans l'algorithme: Nous pouvons utiliser
ce genre de contrainte pour les enfants Les tches
qui ne faisaient pas partie de la slection (donc nous
ne voulons pas de les dplacer, de sorte qu'ils sont
considrs comme des dlais leurs parents).

Else: Nous allons aussi automatiquement niveler les


enfants tches (rcursivement) de toutes les tches
slectionnes.

Pour que cela soit mis en uvre, nous devons garder


affectation heures de toutes les tches ne sont pas
slectionns.

Coefficients utiliss pour les rgles de l'affectation d'une


tche unique aux ressources pourraient tre rgls avec
une petite interface graphique.

Possibilit d'utiliser une partie minimale / maximale


dcalages entre les tches peuvent tre dfinies.

Comme nombre de ressources de plus en plus par des


tches augmente galement les efforts ncessaires, nous
pourrions galement prendre en charge le cas lors de
l'attribution de plusieurs tches la mme ressource dans
le mme temps rduit galement l'efficacit de cette
ressource (temps pass pour passer de 1 tche l'autre,
revenir o la ressource a quitt l'ancienne tche ...
consomme un peu de temps dans la pratique. Cela ne
veut pas aussi simple mettre en uvre que le cot de
plusieurs ressources par tche, car elle implique des
modifications des ressources prcdemment affectes
des tches, mais il ne devrait pas tre un gros problme.

Nous pourrions ajouter quelques rgles concernant le


choix de lors de l'attribution des tches aux ressources
des ressources de la disponibilit. Par exemple:

Ressources choix prfrence parmi l'ensemble des


ressources disponibles (je prfre attribuer la
ressource R1 au lieu de R2, si possible).

Ressources choix prfrence fonde sur les tches


parentales affectations (Si R1 traite de la tche
parent, il est prfrable si elle traite galement de la
tche de l'enfant si possible).

Il a t choisi de toujours
remplir PathNode_Type .TaskPaths avec la carte calcule
de tches accessibles dans PathsManager ::
completeTriedPath . Cela peut tre conteste que dans
certains cas, cette information sera inutile. Les cas sont
quand nous compltons un chemin qui se traduit par un
changement d'un successeur direct (ne faisant pas partie
du chemin critique) en raison de la stratgie d'affectation
seulement. Dans ce cas particulier, nous
n'appelons PathsManager ::
findPossibleBetterPathForTask mthode, de sorte que la
population peut tre inutile. Cependant, nous devons
nous assurer qu'il peut encore tre calcul plus tard (si le
chemin est choisi pour tre forc). Nous pourrions donc
penser peupler cette carte que lorsque ncessaire, mais
cela a 2 inconvnients majeurs:

Dans tous les cas, la carte est utilise, il faut d'abord


tester si elle a t initialise avant de savoir si une
tche est accessible.

Afin de calculer les tches accessibles, il faut ajouter


un pointeur vers le parent PathNode_Type
chaque PathNode_Type objet.

[ Modifier ]Contacts
Tout commentaire, suggestion, remarque, ide ... est la
bienvenue.
Je prvois sur l'amlioration de cet algorithme beaucoup, et
trs reconnaissants toute aide que vous pouvez donner ce
sujet.
Vous pouvez utiliser la page de discussion ou mon email
contribuer.
Merci
Muriel Salvan