Ressource Algorithme. Leveling c. 0.20090312a

Ce document est actuellement un projet alpha.   Il est destiné à être beaucoup changé, même complètement réécrite si nécessaire.   L'algorithme tel que décrit encore manque quelques fonctionnalités encore.   Il est modifié ainsi que les   tests de régression qui apporte de   nouvelles usecases.   Il est encore rendu public de donner des   idées et déjà obtenir des   commentaires.   Actuellement 24 usecases de régression sont couverts avec   succès par cet algorithme.

Contenu

 [ Hide ]

1 Objectif

2 Données d' entrée

3 Les données de sortie

4 conventions

5 Vue d' ensemble

o 5.1 Principe de base

o 5.2 Computing dynamiquement l'importance des tâches

o 5.3 Réorganisation des tâches et de se souvenir: l'arbre des chemins

o 5.4 Plusieurs façons d'attribuer une tâche à ses ressources disponibles

o 5,5 architecture et les composants Algorithme

o 5.6 Résumé Algorithme

6 Explication détaillée

o 6.1 Premières explications, types de données

6.1.1 Identifier la façon dont une tâche est assignée à ses ressources disponibles

6.1.2 conséquences d'enregistrement de l'affectation d'une tâche

6.1.3 tâches Réorganiser, remplaçant branches, chemins de mémoire

6.1.4 La structure principale stockant la façon dont les tâches sont attribuées aux ressources

o 6.2 Les noms de méthode regroupés par des acteurs

7 Les méthodes d'algorithme détaillées

o 7.1 Solution Manager

o 7.2 affectation des tâches Gestionnaire

o 7.3 Gestionnaire d'importance

o 7.4 Chemins Gestionnaire

8 Les implémentations actuelles

o 8.1 Ruby

8.1.1 informations d'accès et téléchargement

9 Remarques

10 idées pour l' amélioration

11 contacts

[ Modifier ]Objectif

Le but de cet article est de présenter un algorithme libre de mise à niveau des ressources qui peuvent être mis en œuvre facilement.

Il donnera des structures de données simples et des fonctions simples qui peuvent être presque copiés / collés à courir. On suppose que le lecteur possède déjà une connaissance de base de la gestion de projet, ce qui signifie qu'il sait sur le problème de la mise à niveau des ressources à l'intérieur d'un projet.

[ Modifier ] Lesdonnées d'entrée

Voici les notions l'algorithme traite en entrée:

Ressources: ils contiennent les attributs suivants:

Calendrier des disponibilités: il est un calendrier contenant un certain nombre d'heures de travail pour chaque

jour depuis le début jusqu'à la fin du projet.

Tâches: ils contiennent les attributs suivants:

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

Dimensionnement: il mesure le nombre d'heures de travail nécessaires pour accomplir la tâche.

Liste des successeurs: une liste d'autres tâches qui ne peuvent pas commencer à moins celle-ci est terminée.

Liste des ressources assignables: une liste de références aux ressources qui peuvent être affectées à cette

tâche. Pour chaque ressource assignable, il est possible d'indiquer un montant maximal d'heures de travail

pour cette association.

Différentes façons d'attribuer un ensemble de ressources à une tâche (l'algorithme peut essayer plusieurs tentatives et choisir le meilleur). Chaque voie peut être réglé compte tenu de certains paramètres humains. Les paramètres sont médité avec des coefficients:

Il peut être préférable d'affecter seulement 1 ressource à une tâche si possible même si la tâche est un peu

retardé.

Il peut être préférable de ne pas modifier les tâches assignées d'une ressource trop souvent.

Il peut être préférable pour une tâche de réutiliser les mêmes ressources que ses prédécesseurs.

Les plus de ressources travaillent sur une tâche, plus l'effort qu'il faudra pour terminer la tâche en raison de

contraintes de la communication humaine.

[ Modifier ] Lesdonnées de sortie

Voici les informations de l'algorithme donne en sortie:

Pour chaque ressource:

Calendrier des tâches à travailler sur: pour chaque jour, un ensemble de tâches et de leurs heures de travail

correspondant.

[ Modifier ]Conventions

Les conventions de dénomination suivantes sont valables pour les explications suivantes:

Ri représente une ressource (numéro i).

Ti représente une tâche (nombre i).

[A, B, C] représente une liste contenant des éléments A, B et C.

... Représente une séquence (pourrait être undefined) des articles. Peut être utilisé dans les listes ([A, ..., Z]).

carte <TypeA, TypeB> représente un type de carte, dont les clés sont de type TypeA et les valeurs de type TypeB.

liste <TypeA> représente un type de liste, le stockage des articles de type TypeA.

[NAMEA: TypeA, titreB: TypeB, ...] représente une liste d'éléments numériques finis qui ont un nom donné et un type donné. Cela peut être considéré comme une structure de données d'enregistrement. Les valeurs d'une telle structure peuvent être abrégées [ValueA, ValueB], étant donné que ValueA est affectée à l'attribut NAMEA, et ainsi de suite.

T.Priority représente la priorité de la tâche T.

T.Sizing représente le nombre d'heures nécessaires pour compléter T.

T.MaximalResourceAllocation [R] représente le nombre maximal d'heures de la ressource R peut travailler sur la tâche T.

T.Predecessors représente la liste des prédécesseurs de T.

T.SharingResourcesTasksID est un identifiant qui est le même pour toutes les tâches qui peuvent partager au moins 1 ressource. Elle peut être considérée comme un identifiant d'une partition des tâches. Il identifie toutes les tâches qui pourraient influencer les uns des autres en raison des affectations de ressources.

Map.keys représente la liste contenant toutes les clés 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 ]Présentation

[ Modifier ]Principe de baseL'idée principale de l'algorithme est de considérer, pour chaque tâche, les ressources disponibles qui pourraient travailler pour elle. Par conséquent, un calendrier de la disponibilité des ressources pour chaque tâche est construit.

Ensuite, les tâches sont assignées 1 par 1, du plus important au moins important, à leurs ressources disponibles. Chaque fois qu'une tâche est assignée, les ressources disponibles des autres tâches sont mises à jour en conséquence.

http://resourcelevel.sourceforge.net/wiki/index.php/File:ResAvlCreation.png

http://resourcelevel.sourceforge.net/wiki/index.php/File:ResAvlAssignment.png

[ Modifier ]Computing dynamiquement l'importance des tâchesL'efficacité de l'algorithme réside dans l'ordonnancement des tâches; qui est le calcul de l'importance des tâches. Il est obligatoire que les plus importants (les tâches hautement prioritaires) sont affectés à leurs ressources avant les autres, si possible.

Toutefois, il est possible que les tâches de faible priorité doivent être attribués avant les hautement prioritaires, sinon ils retarderaient plus grands encore prioritaires en raison de dépendances. Ces retards peuvent être vus que lorsque nous attribuons des tâches loin dans l'avenir, et peuvent difficilement être considérés lors de l'attribution premiers.

Par conséquent, le calcul de l'importance d'une tâche nécessite d'essayer toutes les affectations possibles des tâches aux ressources. Il est impossible en raison de contraintes de performance.

Ceci est la raison pour laquelle l'algorithme fait une première sorte de tâches, en fonction de l'importance simplement calculé (en utilisant des priorités 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 tâche est retardée, mais aurait pu être affecté aux ressources dans le passé qui ont déjà été affecté à une autre tâche. Par conséquent, l'ordre des tâches est modifié dynamiquement en fonction de ces résultats, 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 prévenus ou les chemins les moins chers.

[ Modifier ] lestâches de Réorganiser et se souvenir: les chemins arbreL'idée principale étant que nous devons trouver le meilleur type possible des tâches, l'algorithme doit garder une trace de tous les chemins essayé. Ceci induit naturellement la création d'un arbre de tous les chemins essayé déjà rencontrés dans l'algorithme.

Chaque nœud de cet arbre représente une tâche assignée à ses ressources d'une certaine façon. Une branche de cet arbre représente une sorte donnée des tâches, et associé à chaque noeud sont les conséquences d'une telle cession (si elle retarde à tort d'autres tâches ou non).

Ensuite, l'algorithme peut être interprété comme trouver le meilleur chemin entre cet arbre, qui est celle qui minimise les conséquences.

Voici un exemple d'une cession qui doit réorganiser les tâches.

[ Modifier ]Plusieurs façons d'assigner une tâche à ses ressources disponiblesChaque fois qu'une tâche est assignée à certaines de ses ressources, plusieurs tentatives sont faites pour le faire différemment, et alors la meilleure solution est maintenue. Chaque tentative est enregistrée, avec les conséquences qu'elle a en termes de retards de tâches, et il est alors possible de choisir entre les différentes façons dont l'un est le meilleur.

[ Modifier ]architecture et les composants AlgorithmeAfin de mieux comprendre l'algorithme, quelques acteurs peuvent être définis.

Algorithme point d'entrée représente la principale méthode de l'algorithme, la manipulation des entrées et sorties comme décrit précédemment.

Le gestionnaire de l'importance gère l'ordre des tâches et leur importance. Il

crée l'ordre initial des tâches et

met à jour l'importance des tâches.

Le gestionnaire de solution essaie d'attribuer une liste triée des tâches à leurs ressources. Son but est de trouver différentes façons de les affecter et à comparer plusieurs solutions pour obtenir le meilleur.

Le gestionnaire de la répartition des tâches tente d'assigner une seule tâche à ses ressources. Il met ensuite à jour toutes les informations pertinentes qui pourraient être touchés sur d'autres tâches. Enfin, il vérifie si d'autres tâches peuvent accepter le rendez-vous.

Les chemins gestionnaire stocke tous les chemins essayé (les trie de tâches) l'algorithme obtenu, et pour chacun d'entre eux stocke les conséquences de ce chemin eu sur les tâches. Ensuite, ce gestionnaire donne la possibilité de récupérer le meilleur chemin possible en fonction de cette information.

[ Modifier ]Résumé AlgorithmeL'algorithme peut être résumé ainsi:

1. Calculer les dates de début minimales de chaque tâche, étant donné que toutes les ressources disponibles

pourraient travailler pour eux, et en prenant en considération les dépendances.

http://resourcelevel.sourceforge.net/wiki/index.php/File:AlgoStep1.png

2. Trier les tâches par ordre d' importance simple. L'importance est calculée de manière récursive que la valeur

maximale entre la priorité de la tâche et l'importance de tous ses successeurs directs (successeurs qui pourrait

commencer juste après l'achèvement de cette tâche)

3. Appel d' une méthode récursive qui tente d'assigner des tâches 1 par 1:

3.1. Essayez plusieurs façons d'attribuer la tâche à ses ressources disponibles. Pour chaque voie:

3.1.1. Calculer les conséquences de cette cession dans les tâches suivantes non encore attribués (calculer

leur nouvel horaire minimal, selon de la disponibilité et les tâches des nouvelles ressources des dépendances).

3.1.2. Terminez la mémoire de chemins essayé avec ces informations.

3.1.3. Si l'affectation ne se déplace pas des tâches (leur minimum de date de fin) qui sont plus importants que

ceux déjà attribués, appelez récursivement la méthode qui assignera la tâche suivante dans la liste. Rappelez

- vous toutes les solutions possibles renvoyées par cet appel, ainsi que des sentiers meilleurs possibles , il

peut proposer en cas de impossibilities.Once toutes les itérations ont été essayés, soit renvoyer les solutions

possibles, ou trouver des chemins meilleurs possibles si aucune solution n'a été trouvée.

3.2. S'il y a une meilleure voie qui peut être prise à ce stade, faire en revenant aux itérations avec le nouveau

chemin.

4. Choisir la meilleure solution parmi tous ceux mémorisés.

[ Modifier ]Explication détaillée

[ Modifier ]Premières explications, les types de données[ Modifier ]Identifier la façon dont une tâche est assignée à ses ressources disponibles

Il y a un type de données identifiant une tâche assignée d' une certaine manière à ses ressources (il y a une manière itérative d'assigner des tâches aux ressources, par exemple d' abord essayer d'affecter autant de ressources que possible pour mettre fin plus tôt, puis essayez d'attribuer un ensemble minimal de des ressources à la tâche afin d' éviter la complexité de communication , ...). Chaque moyen d'assigner une tâche est identifiée par un numéro d'itération. Par conséquent , il est possible de revenir à une certaine façon de la répartition des tâches en se souvenant de cet identifiant. Numéros de Iteration commencent à partir de 0 et 1 augmentent de 1 pour chaque tâche. Ce type de données est appeléeAssignedTaskID_Type . Une façon d'assigner une tâche à ses ressources disponibles est enregistrée dans une autre structure, stocker des heures de travail affectées par ressource, par jour: TaskAssignmentSolution_Type .

[ Modifier ]conséquences d'enregistrement de l'affectation d'une tâche

Quand une tâche est assignée à ses ressources, il modifiera les disponibilités des ressources pour d' autres tâches, et peut - être changer l'horaire de ces tâches. Cela peut être inoffensif, mais il peut aussi être pas rentable pour la solution finale.Par conséquent , il est nécessaire de se rappeler les conséquences de chaque mission sur les autres tâches. 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 tâches dont la date fin minimale ont été décalées d'une cession. Il est un arbre parce que ces changements se produisent de manière récursive: l'affectation de T1 déplace T2 ( en prenant ses ressources), puis T2 sera également déplacer T3 parce T3 dépend de T2.

[ Modifier ] lestâches de réapprovisionnement, le remplacement des branches, des chemins de mémoire

Il est nécessaire parfois d'effectuer une réorganisation des tâches à attribuer. Quand nous essayons d'assigner une séquence de tâches à des ressources, il est possible que nous réalisons cette séquence est pas optimale ( ce qui signifie l'ordre original de la liste des tâches peut être optimisée). Cette optimisation se fait en déplaçant vers le bas certaines tâches ci - dessous d' autres, donc résultant en une nouvelle tâche ordonner que nous l' espérons, conduira à une meilleure solution ,une fois les tâches sont assignées aux ressources. Une branche de tâches est représenté par le type Branch_Type .

Chaque ordre différent des tâches peut être considéré comme un chemin dans l'arbre de toutes les possibilités de l'affectation de tâches à ses ressources. Chaque nœud de cet arbre est identifié à la tâche et la façon dont il a été affecté à ses ressources (le nombre d'itérations). Pour mieux trouver des chemins optimisés, il est nécessaire pour stocker chaque chemin essayé, et la raison pour laquelle certains d'entre eux ont été considérés comme non optimisé. Par conséquent, l'algorithme se souvient de l'ordre des tâches et des numéros d'itération ainsi que l'importance de la tâche quand il a été affecté, et la priorité maximale des tâches décalée en raison de cette affectation. Ceci est fait dans une structure arborescente, dont les nœuds représentent une tâche assignée à ses ressources. Dans cet arbre, T2 enfant de T1 signifie que T1 a été affecté d' abord, puis T2. Pour représenter cet arbre, le type PathNode_Type a été créé. Par 

conséquent , nous pouvons facilement se rappeler quel chemin a déjà été essayé et n'a pas fonctionné en raison de lapriorité des tâches changent.

[ Modifier ]La structure principale stockant la façon dont les tâches sont attribuées aux ressources

L'algorithme utilise une structure de données spéciale qui représente une configuration des tâches assignées aux ressources. Cette structure (appelée AssignmentInfo_Type ) est une carte stockant des informations par tâche. L'idée derrière est d'imaginer des ressources comme des conteneurs des efforts de tâches. Au début de l'algorithme, les heures de travail des ressources sont vides (non affecté à une tâche), et l'algorithme va assigner des tâches 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 de méthode regroupés par des acteurs

Suite à l' architecture précédente de l'algorithme, voici les noms des méthodes qui seront utilisées. Fichier: AlgoMethods.png

[ Modifier ]Les méthodes d'algorithme détaillées

Principal

[ Modifier ]Solution ManagerSolutionManager :: findAssignmentForTasksList

SolutionManager :: tryPossibleSolution

SolutionManager :: assignCompleteTask

[ Modifier ]Assignment Task ManagerTaskAssignmentManager :: assignPossibleSolution

TaskAssignmentManager :: shiftChildrenTasks

TaskAssignmentManager :: shiftTaskMinimalDates

TaskAssignmentManager :: computeShiftedDateHours

TaskAssignmentManager :: removeCountedHoursFromResourcesBuffers

TaskAssignmentManager :: removeResourcesFromOtherTasks

TaskAssignmentManager :: notifyMinimalEndDateChanged

[ Modifier ]Importance gestionnaireImportanceManager :: populateImportances

ImportanceManager :: getSortedTasks

ImportanceManager :: updatePredecessorsImportances

ImportanceManager :: updateImportance

[ Modifier ] Leschemins GestionnairePathsManager :: findPossibleBetterPathForTask

PathsManager :: computeShiftedTasksList

PathsManager :: findUnknownPathReorderingShiftedTasks

PathsManager :: computeNewPathMovingTask

PathsManager :: validateUnknownPath

PathsManager :: reorderBranch

PathsManager :: findPossibleBetterPathAlreadyKnown

PathsManager :: getBestPathAmongBestShiftedImportancePaths

PathsManager :: findSmallestShiftedConsequencesPaths

PathsManager :: completeTriedPath

[ Modifier ] Lesimplémentations actuelles

[ Modifier ]RubyLa première mise en œuvre de cet algorithme a été fait dans le langage Ruby ( http://www.ruby-lang.org ). La régression a été faite dans cette langue, aussi.

[ Modifier ]Informations d'accès et téléchargement

Si vous voulez essayer l'algorithme et exécuter les cas de régression avec elle, vous devrez:

1. Obtenez Ruby si pas déjà livré avec votre système d'exploitation

2. Obtenez un client SVN si pas déjà livré avec votre système d'exploitation

3. Caisse du dépôt SVN dans un répertoire ( "svn co https://resourcelevel.svn.sourceforge.net/svnroot/resourcelevel ")

4. Allez dans le répertoire "./resourcelevel/trunk/ruby/test".

5. Tapez "ruby -I ../ lib -w run.rb". Cela exécutera les tests de régression, et afficher le résultat après une sortie grande de débogage. Les dernières 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/resourcelevel/trunk/ruby/

[ Modifier ]Remarques

Habituellement, ce n'est pas la philosophie de définir dates de début / fin et les durées basées sur les efforts prévus comme il est rarement réaliste lorsqu'ils traitent avec plusieurs ressources. Cependant, il est très pratique et réaliste quand il y a seulement 1 ressources par tâche, et un facteur supplémentaire augmentant l'effort de tâches sur la base de la complexité des ressources a été prise en compte (TODO). Cela donne cet algorithme plus de crédibilité, même pour de multiples ressources par tâche.

La façon dont les tâches sont assignées aux ressources est pas exhaustive. Il existe de nombreuses différentes façons de le faire. L'algorithme essaie chaque fois de plusieurs façons, et évaluera ensuite l'affectation finale pour sélectionner le meilleur.

La façon dont les tâches sont triées est (ou devrait être, en cas de bugs) exhaustive. Cela signifie qu'une fois qu'il a été décidé comment les tâches sont attribuées aux

ressources, l'algorithme doit trouver le genre optimale des tâches pour assurer ceux avec la plus grande priorité sera accordée en premier.

Il y a 2 goulots d'étranglement identifiés à ce jour:

PathsManager :: findPossibleBetterPathForTask  : Un

goulot d'étranglement de performances de haut

niveau. Si cette méthode donne de meilleurs

chemins d'une manière stupide, il peut soit entraîner

les mêmes problèmes que ceux rencontrés

auparavant par des chemins précédents, ou

entraîner des chemins choisis au hasard et donc

jamais trouver une bonne solution facilement.

TaskAssignmentManager ::

notifyMinimalEndDateChanged : Un faible goulot

d'étranglement au niveau. Cette méthode est

appelée très souvent, comme pour chaque mission

d' essayer, il va modifier toutes les tâches affectées

de manière récursive due à l' élimination des

ressources ou les dépendances de tâches.

[ Modifier ] Desidées pour l' amélioration

Dans l'algorithme, utilisez un cache pour SolutionManager :: findAssignmentForTasksList appelle: il est possible qu'il est appelé plusieurs fois pour la même iCurrentTasksList, chacun d'entre eux à partir de la même date de départ avec les mêmes ressources affectées dans la gamme de date [date de début - > la fin du projet]. Dans ce cas, le retour des solutions déjà calculées. Ces répétitions d'appels seraient dus au fait que nous essayons de plusieurs différentes répartition des ressources par tâche, et certains peuvent entraîner les mêmes appels (à valider si avant la mise en œuvre).

Prendre d' autres contraintes en compte, que les délais ou les coûts , par exemple. Les délais seraient très faciles à mettre en œuvre, comme nous traitons déjà avec des dépendances nous ne pouvons pas se déplacer dansTaskAssignmentManager :: shiftChildrenTasks méthode. Il serait alors juste nécessiter des modifications minimes TaskAssignmentManager :: shiftChildrenTasks méthode.

Le calcul de l' effort nécessaire peut être un peu aléatoire. Il est un moyen de modéliser les erreurs humaines dans dimensionnements ou les diverses fluctuations que nous ne pouvons pas prévoir en raison de facteurs externes qui entravent lajournée à la performance du jour des ressources. Ceci peut être mis

en oeuvre dans l'itération de la méthode principale SolutionManager :: findAssignmentForTasksList . Il peut également être réglé en utilisant des algorithmes génétiques (comme cela semble être la prochaine tendance dans le nivellement du projet de gestion des ressources) pour modéliser les erreurs humaines qui pourraient être un peu prévisible. Le bon point est que nous avons juste besoin de modifierSolutionManager :: findAssignmentForTasksList mettre en œuvre toute stratégie que nous voulons à ce sujet .

Nous pouvons ajouter la notion que les ressources ne sont pas égaux devant la même tâche. Certains seront plus efficaces que d' autres (connaissances techniques, besoin de formation ...). Nous voulons toujours affecter plusieurs ressources pour la tâche (comme il peut être préférable de former des ressources R1 et l' utiliser sur la tâche que d' utiliser directement R2 ressources sur elle, même sans formation - peut - être parce que R2 doit travailler sur une autre tâche prioritaire dans le en même temps). Dans ce cas , nous pouvons changer l'effort nécessaire d'une tâche dans l'algorithme en fonction de la ressource est affectée à elle. Cela se fait aussi dans l'itération principale de SolutionManager :: findAssignmentForTasksList .

Nous pourrions sélectionner un sous-ensemble de tâches à niveau. 2 possibilités:

Si nous avons mis en place des échéances

contraintes dans l'algorithme: Nous pouvons utiliser

ce genre de contrainte pour les enfants Les tâches

qui ne faisaient pas partie de la sélection (donc nous

ne voulons pas de les déplacer, de sorte qu'ils sont

considérés comme des délais à leurs parents).

Else: Nous allons aussi automatiquement niveler les

enfants tâches (récursivement) de toutes les tâches

sélectionnées.

Pour que cela soit mis en œuvre, nous devons garder affectation heures de toutes les tâches ne sont pas sélectionnés.

Coefficients utilisés pour les règles de l'affectation d'une tâche unique aux ressources pourraient être réglés avec une petite interface graphique.

Possibilité d'utiliser une partie minimale / maximale décalages entre les tâches peuvent être définies.

Comme nombre de ressources de plus en plus par des tâches augmente également les efforts nécessaires, nous pourrions également prendre en charge le cas lors de l'attribution de plusieurs tâches à la même ressource dans

le même temps réduit également l'efficacité de cette ressource (temps passé pour passer de 1 tâche à l'autre, revenir à où la ressource a quitté l'ancienne tâche ... consomme un peu de temps dans la pratique. Cela ne veut pas aussi simple à mettre en œuvre que le coût de plusieurs ressources par tâche, car elle implique des modifications des ressources précédemment affectées à des tâches, mais il ne devrait pas être un gros problème.

Nous pourrions ajouter quelques règles concernant le choix de lors de l'attribution des tâches aux ressources des ressources de la disponibilité. Par exemple:

Ressources choix préférence parmi l'ensemble des

ressources disponibles (je préfère attribuer la

ressource R1 au lieu de R2, si possible).

Ressources choix préférence fondée sur les tâches

parentales affectations (Si R1 traite de la tâche

parent, il est préférable si elle traite également de la

tâche de l'enfant si possible).

Il a été choisi de toujours remplir PathNode_Type .TaskPaths avec la carte calculée de tâches accessibles dans PathsManager :: completeTriedPath . Cela peut être contestée que dans certains cas, cette information sera inutile. Les cas sont quand nous complétons un chemin qui se traduit par un changement d'un successeur direct (ne faisant pas partie du chemin critique) en raison de la stratégie d'affectation seulement. Dans ce cas particulier, nous n'appelons PathsManager :: findPossibleBetterPathForTask méthode, 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 nécessaire, mais cela a 2 inconvénients majeurs:

Dans tous les cas, la carte est utilisée, il faut d'abord

tester si elle a été initialisée avant de savoir si une

tâche est accessible.

Afin de calculer les tâches accessibles, il faut ajouter

un pointeur vers le parent PathNode_Type à

chaque PathNode_Type objet.

[ Modifier ]Contacts

Tout commentaire, suggestion, remarque, idée ... est la bienvenue.

Je prévois sur l'amélioration de cet algorithme beaucoup, et très reconnaissants à toute aide que vous pouvez donner à ce sujet.

Vous pouvez utiliser la page de discussion ou mon email à contribuer.

Merci

Muriel Salvan