Discussion :

[chouki]

Bonjour,
je voudrais essayer de calculer le temps d'exécution d'une méthode est il possible de le faire en java ?

Cordialement

[darkxan]

Un moyen simple est d'utiliser la méthode currentTimeMillis ou nanoTime de la classe System et faire simplement une différence. Sinon, tu peux aussi utiliser des outils de monitoring comme HPROF (utilisable via un argument dans le lancement de la JVM). http://java.sun.com/developer/techni...ing/HPROF.html

[Jimalexp]

C'est intéressant pour optimiser ses algorithmes .

[chouki]

Avec CurrentTimeMillis avec deux exécution sa donne 2 résultats différents!!!

[Uther]

Bien sur! C'est le principe même!

Tu fais un currentTimeMillis en début de l'opération a mesurer et tu met le résultat dans une variable. A la fin du traitement tu fais la différence entre un nouveau currentTimeMillis et la valeur sauvegardée pour obtenir le temps en ms.

[nouknouk]

Avec CurrentTimeMillis avec deux exécution sa donne 2 résultats différents!!!

Bien sur! C'est le principe même!
Tu fais un currentTimeMillis en début de l'opération a mesurer et tu met le résultat dans une variable. A la fin du traitement tu fais la différence entre un nouveau currentTimeMillis et la valeur sauvegardée pour obtenir le temps en ms.

Je pense qu'il voulait dire qu'il a testé deux fois son application et qu'il a obtenu des résultats sensiblement différents.

Attention pour le calcul des très petites valeurs (genre une fonction qui ne prend qu'une milliseconde): currentTimeMillis ou nanoTime ne sont pas forcément précis à la milliseconde (respectivement la nanoseconde) près.
Dans certains cas, tu peux même avoir des imprécisions de l'ordre de 15msec.

C'est pourquoi il est en règle générale préférable de faire des tests de performance avec les outils prévus pour (comme Hprof, mais également avec les outils intégrés dans certains IDE: c'est le cas avec NetBeans ; j'imagine que l'équivalent doit exister sur Eclipse).

L'autre possibilité pour réduire les imprécisions est de mesurer le temps pris par l'exécution de la fonction non pas pour une exécution, mais pour 1000 exécutions à la suite (dans une boucle). Tu n'as ensuite plus qu'à diviser le delta de temps obtenu entre le début et la fin de la boucle par 1000.

[Jimalexp]

Il vaut mieux faire une moyenne de toute façon. Le système d'exploitation et même la JVM peuvent engendrer ces différences en temps d'exécution.

[chouki]

Avec ce bout de code

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
 
 
import java.util.*;
public class GetExecutionTimes
{
  public GetExecutionTimes(){}
  public static void main(String args[])
  {
    long startTime = System.currentTimeMillis();
    GetExecutionTimes ext=new GetExecutionTimes();
    ext.callMethod();
    long endTime = System.currentTimeMillis();
    System.out.println("Total elapsed time in execution of method callMethod() is :"+ (endTime-startTime));
  }
  public void callMethod(){
    System.out.println("Calling method");
    for(int i=1;i<=10;i++)
    {
      System.out.println("Value of counter is "+i);
    }
  }
}

le résultat de

Code :

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

1
2
 
 System.out.println("Total elapsed time in execution of method callMethod() is :"+ (endTime-startTime));

est 0

[adiGuba]

Salut,

Il me semble que tout a déjà été dit :

Attention pour le calcul des très petites valeurs (genre une fonction qui ne prend qu'une milliseconde): currentTimeMillis ou nanoTime ne sont pas forcément précis à la milliseconde (respectivement la nanoseconde) près.
Dans certains cas, tu peux même avoir des imprécisions de l'ordre de 15msec.

a++

[nouknouk]

le résultat de [...]est 0

Effectivemet: le temps nécessaire à l'exécution de ta fonction est très petit, en dessous de la milliseconde.
D'où l'idée d'appeller non pas une seul fois ta fonction, mais beaucoup de fois (ci-dessous 100 000 fois) et de faire une moyenne:

Code :

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

1
2
3
4
5
6
7
 
    for (int i=0; i < 100000; ++i) {
        ext.callMethod();
    }
    long endTime = System.currentTimeMillis();
    System.out.println("Total elapsed time in execution of method callMethod() is :"+ ((endTime-startTime)/100000));
  }

EDIT: grilled

[chouki]

hein!! , je n'y comprends rien TOUJOURS 0

[Uther]

Peut être que une itération se fait en moins de 1 ms.
Essaie avec :

Code :

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

System.out.println("Total elapsed time in execution of method callMethod() is :"+ ((double)(endTime-startTime)/100000) + "ms");

[chouki]

Peut étre qu'il faut viser + haut que 100000 je vais tester

[chouki]

C'est mieux ainsi

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
 
 
import java.util.*;
public class GetExecutionTimes
{
  public GetExecutionTimes(){}
  public static void main(String args[])
  {
    long startTime = System.currentTimeMillis();
    GetExecutionTimes ext=new GetExecutionTimes();
 
        ext.callMethod();
 
    long endTime = System.currentTimeMillis();
 
    System.out.println("debut"+ (endTime));
    System.out.println("fin"+ (startTime));
    System.out.println(endTime-startTime);
 }
 
  public void callMethod(){
   // System.out.println("Calling method");
    for(int i=1;i<=100000;i++)
    {
     System.out.println(i);
    }
  }
}

[sassion]

Bonjour,

comment peut-on calculer le temps CPU de plusieurs programmes qui s’exécutent au même temps. dans mon cas je travaille sur des agents (jade) en java donc toutes mes classes s’exécutent simultanément et je sais pas quand est ce que je dois mettre le System.currentTimeMillis().

Cordialement

[deathness]

Bonjour,

comment peut-on calculer le temps CPU de plusieurs programmes qui s’exécutent au même temps. dans mon cas je travaille sur des agents (jade) en java donc toutes mes classes s’exécutent simultanément et je sais pas quand est ce que je dois mettre le System.currentTimeMillis().

Cordialement

Utilise plutôt des programmes de traçage, tel que décrit dans ce tuto http://arodrigues.developpez.com/tut...ation-java-ee/

[mohamine1989]

Pour y parvenir, il y a un moyen tous simple, relever l'heure avant la première instruction de ton programme, et après la fin de l’exécution de programme, ensuite, faire la différence entre les deux, tous ça en utilisant des instance de la class java.util.Date :

Code :

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

1
2
3
4
5
6
7
8
9
10
java.util.Date uDate = new java.util.Date (System.currentTimeMillis ()); //Relever l'heure avant le debut du progamme (en milliseconde) 
Date dateFin = new Date (System.currentTimeMillis()); //Relever l'heure a la fin du progamme (en milliseconde) 
Date duree = new Date (System.currentTimeMillis()); //Pour calculer la différence
duree.setTime (dateFin.getTime () - uDate.getTime ());  //Calcul de la différence
long secondes = duree.getTime () / 1000;
long min = secondes / 60;
long heures = min / 60;
long mili = duree.getTime () % 1000;
secondes %= 60;
System.out.println ("Temps passé durant le traitement : \nHeures : " + heures + "\nMinutes : " + min + "\nSecondes : " + secondes + "\nMilisecondes : " + mili + "\n");

Ca devrait marcher, A+ .

[hwoarang]

Pour y parvenir, il y a un moyen tous simple, relever l'heure avant la première instruction de ton programme, et après la fin de l’exécution de programme, ensuite, faire la différence entre les deux

Sauf que ca ne marche pas en environnement multithreadé
D'ou l'utilité des outils de debug qui sont fait pour ca (et qui ont necessité pas mal de developpement) et qui seront donc beaucoup plus efficaces que des instrumentations faites vite fait.

[mohamine1989]

Merci beaucoup pour cette précisiant, je n'y est pas pensée, j'y ferai attention la prochaine fois .
A+ .