Discussion :

[Fractaliste]

Bonjour,

En ce moment je travaille sur un projet qui est très gourmand en temps de calculs (optimisation combinatoire toussa).

Et j'ai vu sur mon moniteur de ressource que la consommation CPU ne dépasse jamais les 50%. Je voulais savoir s'il y avait des solutions pour faire comprendre à la JVM qu'il faut qu'elle arrête de faire sa mijaurée et qu'elle hésite pas à prendre ce qui est à disposition.

J'ai vu pas mal de sujets sur ce forum et ailleurs traitant de l'allocation RAM mais je n'ai rien vu concernant la CPU... Any suggestions ?

Merci d'avance ; )

[gronono]

Salut,

Si la JVM n'utilise pas tout le CPU, alors elle fait de I/O wait; donc vérifie si tu n'as pas d'attente de disque dur / reseau / base de données, ... dans ton programme.
Si tu veux diminuer les temps d'attente, il faut paralléliser les traitements pour que le CPU est du taf pendant que la JVM attend la/les ressources bloquantes

[rg77140]

Bonjour,

Si ton application est mono-thread et que tu as deux cœurs il semble normal que tu vois ton CPU à 50%. En effet tu as un CPU à 100% (celui qui gère ton thread), l'autre à 0% (le premier CPU s'occupant du thread, celui-ci n'a rien à faire), ça fait 50% de moyenne. Si tu veux utiliser tes deux CPU à 100% il faut que ton application soit multi-threadée.

Romain.

[ra77]

Salut,

Je confirme les dires de gronono, la JVM va utiliser toute la puissance CPU nécessaire pour fonctionner.
Pour savoir ce que fait la JVM, utilise des thread dump et/ou un profiler (VisualVM le fait mais si tu veux une solution payante, il y a JProfiler ou YourKit JavaProfiler)

Dernière chose, pour la consommation CPU, n'oublie pas de différencier le cpu système et le cpu user. Et aussi si tu as plusieurs cœurs/cpu sur ton serveur, à quoi correspond les 50% (sur 1 cœur ?, sur tous les cœurs ?)

Antonio

[Fractaliste]

Mon projet est plutôt calculatoire, donc il n'y a pas vraiment de ressources à attendre si ce n'est la CPU justement.

J'ai regardé niveau RAM sur le moniteur de ressource et ma charge d'écriture est très loin des 100%, pareil ma mémoire n'est pas surchargée non plus, idem accès disque dur.

J'ai regardé avec VisualVM et ma classe main n'est jamais en Wait.

Par contre oui ma machine possède deux coeur, et je n'ai pas vraiment de possibilité de multi-threader facilement la librairie de calcul que j'utilise (Choco), ni de vérifier si elle le fait bien. Enfin jvais éplucher la doc si ça se trouve y a une option que j'ai pas activé...

Merci à vous ; )

[rg77140]

Ce n'est pas vraiment la librairie que tu dois multi-threader mais l'exécution de ton application (la librairie doit juste pouvoir être utilisée dans une application multithread afin de ne pas avoir des surprises au niveau des resultats renvoyés, des problèmes de blocages, ou des problèmes de modification concurrentes ...). Dans certains cas ça peut se faire facilement, dans certains cas c'est plus compliqué. Il faut que tu essaies de trouver des choses à faire qui sont indépendantes et qui peuvent donc être faites en parallèles.

Exemples : Imaginons que tu ais une liste de problèmes à résoudre et que chaque problème n'a pas besoin du résultat d'un autre, alors il est assez simple de multithreadé ton application. Tu peux créer un pool de thread, disons 10 par exemple, chaque thread s'occupe d'un des problèmes, lorsque les 10 thread sont pris, le 11ème attends qu'un autre ait finit, puis il prend sa place...

Exemple de code qui pourrait t'aider :

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
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
 
public class TestTest
{
    public static void main(String[] args) throws InterruptedException, ExecutionException
    {
        // déclare un pool de deux thread
        ExecutorService newFixedThreadPool = Executors.newFixedThreadPool(2);
 
        // la classe qui effectue le traitement métier, ici juste un system.out.println
        MontraitementMetier traitement = new MontraitementMetier();
 
        // prépare les taches à exécuter en parallèle
        Collection<Callable<String>> tasks = new ArrayList<Callable<String>>();
        tasks.add(new MontraitementMetierParallelisable(traitement, "1"));
        tasks.add(new MontraitementMetierParallelisable(traitement, "2"));
        tasks.add(new MontraitementMetierParallelisable(traitement, "3"));
        tasks.add(new MontraitementMetierParallelisable(traitement, "4"));
        tasks.add(new MontraitementMetierParallelisable(traitement, "5"));
 
        // exécution en parallèle du traitement. Appel MontraitementMetierParallelisable.call
        List<Future<String>> resultats = newFixedThreadPool.invokeAll(tasks);
 
        // fermeture du pool
        newFixedThreadPool.shutdown();
 
        // travail sur les resultat si necessaire
        for (Future<String> resultat : resultats)
        {
            System.out.println(resultat.get());
        }
    }
 
    public static class MontraitementMetier
    {
        public void printString(String string)
        {
            System.out.println(string);
        }
    }
 
    public static class MontraitementMetierParallelisable implements Callable<String>
    {
        private MontraitementMetier traitement;
 
        private String valeurAtraiter;
 
        public MontraitementMetierParallelisable(MontraitementMetier traitement, String valeurAtraiter)
        {
            this.traitement = traitement;
            this.valeurAtraiter = valeurAtraiter;
        }
 
        /**
         * (methode de remplacement) {@inheritDoc}
         * 
         * @see java.util.concurrent.Callable#call()
         */
        public String call() throws Exception
        {
            traitement.printString(valeurAtraiter);
            // ce qui est renvoyé dans cette fonction est ajouté dans List<Future<String>> resultats
            return valeurAtraiter + "traite";
        }
    }
}

Romain.

[Fractaliste]

C'est les calculs que je délègue à ma librairie qui sont vorace justement, donc c'est elle qu'il faudrait que je multi-thread...

J'aurais jamais cru qu'un jour je regretterais d'avoir un dual-core é_è

Donc faut que je plonge dans les sources de ma librairie pour la multi-threader, jvais voir à quoi ça ressemble j'ai peur que ça soit une perte de temps (surtout que j'ai pas 4 coeurs à exploiter non plus).

Par contre je garde ton bout de code sous le coude j'ai souvent essayé de bricolé des pools de threads sans succès !

Merci ; )