Bonjour,
je voudrais essayer de calculer le temps d'exécution d'une méthode est il possible de le faire en java ?
Cordialement
Bonjour,
je voudrais essayer de calculer le temps d'exécution d'une méthode est il possible de le faire en java ?
Cordialement
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
C'est intéressant pour optimiser ses algorithmes .
Développeur en devenir.
A la recherche de toute source approfondissant Merise, UML, Java, l'objet, les design patterns hors GOF et le développement en général.
Recherche également des informations sur les techniques de développement et les bonnes pratiques en terme de programmation en entreprise.
"On en apprends beaucoup plus par la confrontation que par la conciliation"
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.
Mon projet du moment: BounceBox, un jeu multijoueurs sur Freebox, sur PC et depuis peu sur smartphone/tablette Android.
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.
Développeur en devenir.
A la recherche de toute source approfondissant Merise, UML, Java, l'objet, les design patterns hors GOF et le développement en général.
Recherche également des informations sur les techniques de développement et les bonnes pratiques en terme de programmation en entreprise.
"On en apprends beaucoup plus par la confrontation que par la conciliation"
Avec ce bout de code
le résultat de
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); } } }
est 0
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));
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:
EDIT: grilled
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)); }
Mon projet du moment: BounceBox, un jeu multijoueurs sur Freebox, sur PC et depuis peu sur smartphone/tablette Android.
hein!! , je n'y comprends rien TOUJOURS 0
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");
Peut étre qu'il faut viser + haut que 100000 je vais tester
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); } } }
Dernière modification par chouki ; 27/02/2009 à 18h47.
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/
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 :Ca devrait marcher, A+ .
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");
Merci beaucoup pour cette précisiant, je n'y est pas pensée, j'y ferai attention la prochaine fois .
A+ .
Vous avez un bloqueur de publicités installé.
Le Club Developpez.com n'affiche que des publicités IT, discrètes et non intrusives.
Afin que nous puissions continuer à vous fournir gratuitement du contenu de qualité, merci de nous soutenir en désactivant votre bloqueur de publicités sur Developpez.com.
Partager