Discussion :

[in]

Bonjour,

voilà je suis confronté un un pb incompréhensible. Et ça devient assez critique au boulot

J'ai un traitement super long. J'ai donc essayé de l'optimiser pour la machine cible (Solaris 8, 4 procs, 4 Go de RAM). En gros, j'ai multithreadé le traitement (niveau donné et traitement) et je n'hésite pas à bouffer de la mémoire et du proc.

En gros :

• j'ai un programme principal, celui ci lance des threads producteurs dans un threadPoolExecutor (j'ai mis 4 thread pour la taille du Core).
• Ces producteurs écrivent des données dans une ConcurrentLinkedQueue static dans le prog principal qui contient les objets à traiter.
• Le prog principal lance les consommateurs de la meme manière que pour les prod.
• Les producteurs font des poll et traitent les objets lus. Ces objets lus possèdent des méthodes getXXX dont je me sers pour alimenter une hashmap qui cumule les valeurs si la clé existe.

Le problème est que pour environ 1-5 % des données, il y a des erreurs. Les valeurs que j'obtiens sont celles d'un autre objet (les données ne sont pas aléatoires).

Après test, les producteurs extraient les bonnes données et les mettent dans la ConcurrentLinkedQueue. Lorsque je lis cette liste avec les consommateurs, hop, certaines données sont erronées.

Plus fort, si je lance mon traitement depuis Eclipse, pas de pb aucune erreur dans les données.

J'ai essayé plusieurs options sur la ligne de commance java sur Solaris mais aucune ne change la donne.

Ce qui est assez "marrant" c'est que les données erronnées ne concerne pas toujours les mêmes objets mais certains reviennent assez souvent. Les données fausses proviennent quant à elles toujours d'un autre objet.


Avez vous une idée de l'origine du pb ?

la jvm ? (j'utilise la dernière version. Résultats identiques en 32 ou en 64 bits)
solaris ? (apparemment j'ai les deniers patch)

est ce que l'utilisation de références douces ou fantômes (ou un truc comme ça) pourrait me garantir mes résultats ?

d'avance merci à ceux qui liront tout et qui auraient peut être une idée

[KiLVaiDeN]

Salut,

Je ne sais pas si ça va t'aider, mais je sais que sous Solaris, java est lancé en mode "server".

Par défaut, sur les autres plateformes, c'est lancé en mode "client", et je suspecte que le lancement via eclipse lance également la commande en mode "client" ( pas sûr du tout ).

Donc peut-être que tu pourrais lancer ton traitement comme ça :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

java -client etc..

Je pense que ça peut jouer, c'est à vérifier...

A+ bonne chance !

[in]

sous solaris je lance avec -server (entre autre).

Vu l'urgence je suis en train de simplifier le traitement pour avoir des données utilisables par les gens qui grognent . Je ne vais donc pas tester tout de suite ton idée. Merci quand même, je garde ça sous le coude ...

[®om]

à mon avis tu as une erreur dans ton code, tu peux nous montrer?

[in]

à mon avis tu as une erreur dans ton code, tu peux nous montrer?

bon j'espère que ça va pas être trop dur à capter ...
(le code marche bien sous Win je répète)

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
 
Class finance {
 
      // classe principale qui gère les prod et conso
   // contient l'objet queueRA accédée par les 2 types de threads
 
 
    protected static ConcurrentLinkedQueue<ResourceAssignment> queueRA = null;
    private ThreadPoolExecutor threadPoolReader = null;
 
    public Finance(...){
        queueRA = new ConcurrentLinkedQueue<ResourceAssignment>();
        threadPoolReader = new ThreadPoolExecutor(nbThreads,maxSize,timeOut,unit,new LinkedBlockingQueue<Runnable>());
    }
 
 
     protected int traitement() {
		...
             while(itCa.hasNext()){  // une boucle sur des objets de type "Projet"
                                             // se rapporte à des données en bdd
                                             // les données sont récupérées via API propriétaire
 
                      // lancement des producteurs
                      // la classe chargement RA se charge de traiter tous les objets de la liste des taches du projet (ListeTaskCA)
                     // pour chacune des taches, lancement d'un thread Producteur (ParallelChargeRA)
                     ChargementRA ajoutRA = new ChargementRA(listeTaskCA,proj,udf_field_EA,nbThreads);					
						ajoutRA.start();
 
                    // pour chaque truc écrit, on lance un conso
                   while(! (ajoutRA.isTerminated() && queueRA.isEmpty()))
			while( (next = queueRA.poll()) != null ) {
				try {
	                            threadPoolReader.execute(new ParallelFinance(epsId,projWBS,next,listeValeurs/*,connexion*/,datadate/*,listActPostTraitement*/));
				} catch(RejectedExecutionException ree) {
					printAndTrace("[ERROR] Impossible d'exécuter la tache : "+ree.getMessage());
					ree.printStackTrace();
					nbException++;
				}
			}
             }
             ... // on attend la fin des consommateurs
            // on lance la procédure d'insertion des données en bdd
     }//while projet
 
}//class

Les producteurs :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
 
class ParallelChargeRA implements Runnable {
    // les instances de cette classe sont gérées par un pool de thread de la classe chargementRA
 
    //... bref le run
 
   public void run(){
          // chargement via API de données calculées en live
          // le pb de perf est ici ... mais bon c'est pas le sujet
          // un iterator en gros
          listeRAWithLiveSpreads = proj.loadAllResourceAssignmentsWithLiveSpread(	fields, 
								"ActivityObjectId = "+activityOID,
								null,
								spreadFields,
								SpreadPeriodType.MONTH,
								depuis,//debutActivity,
								jusqua,//finActivity, 
								false);
 
 
      while(listeRAWithLiveSpreads.hasNext()) {
	try {
 
		ra = (ResourceAssignment)listeRAWithLiveSpreads.next();
		Finance.queueRA.offer(ra); // on met l'objet dans la liste concurrente de Finance
                // si j'affiche les valeurs de l'objet c'est OK
   } //run
} //class

les consommateurs :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
 
class ParallelFinance implements Runnable {
 
    public voir ParallelFinance (epsId,projWBSId,next /* objet de queueRA */ ...) {
         this.eps = epsId;
	 this.proj = projWBSId;
	 this.ra = next;
	 this.task = ra.getActivityObjectId().toInteger(); // ici valeur OK, on a le bon objet
    }
 
    // ... le run 
   public void run(){
    // on a l'objet de la liste récupéré par poll
    ResourceAssignmentSpread spreadData = ra.getResourceAssignmentSpread();  // le pb serait là ? -> méthode de l'API proprio
    ResourceAssignmentSpreadPeriod spreadPeriod = null;
    Iterator itSpread = spreadData.getSpreadIterator(false)
    resId = ra.getResourceId(); // ici valeur OK
 
    // parcours des données spread (ventilées par période) de l'objet
    while(itSpread.hasNext()){
 
	spreadPeriod = (ResourceAssignmentSpreadPeriod) itSpread.next();
        period = getPeriode(spreadPeriod.getSpreadPeriodStart());
 
        acwp = new Double(spreadPeriod.getActualCost().doubleValue());
	etc = new Double(spreadPeriod.getRemainingCost().doubleValue());
	remainingUnits = new Double(spreadPeriod.getRemainingUnits().doubleValue());
	actualUnits = new Double(spreadPeriod.getActualUnits().doubleValue());
 
        // les 4 dernières valeurs  sont fausses ... parfois
       // elles semblent provenir d'un autre RA 
 
   }
 
 
   } // run
 
}//class