Quel est le meilleur moyen depuis un programme Java d'avoir une idée de
la consommation CPU utilisée pour éxecuter un bout de code : une mesure
du temps écoulé ne me suffit pas car j'ai besoin d'un indice qui prend
en compte la puissance disponible. Y a-t-il moyen d'avoir par exemple le
nombre de bytecode executé suite à l'invocation d'une méthode
quelconque ?
L'emploi d'outil de profiling externe ne répond pas à mon besoin, je
fais des sortes d'applets qui n'ont aucune connaissance à priori sur la
plateforme qui les fait tourner (en particulier la puissance
potentielle, la puissance disponible), mais j'ai besoin d'un indice de
performance constaté à l'éxécution.
Cette action est irreversible, confirmez la suppression du commentaire ?
Signaler le commentaire
Veuillez sélectionner un problème
Nudité
Violence
Harcèlement
Fraude
Vente illégale
Discours haineux
Terrorisme
Autre
Nicolas Delsaux
Le 18.11 2003, Sebastien Devaux s'est levé et s'est dit : "tiens, si j'écrivais aux mecs de fr.comp.lang.java ?"
Bonjour le groupe,
Quel est le meilleur moyen depuis un programme Java d'avoir une idée de la consommation CPU utilisée pour éxecuter un bout de code : une mesure du temps écoulé ne me suffit pas car j'ai besoin d'un indice qui prend en compte la puissance disponible. Y a-t-il moyen d'avoir par exemple le nombre de bytecode executé suite à l'invocation d'une méthode quelconque ?
Tu peux ouvrir le fichier .class avec un quelconque éditeur de bytecode (comme par exemple BCEL ou autres), qui va te permettre depuis ton code Java de manipuler le bytecode de tes fichiers .class, mais aussi de connaître le nombre d'instructions de chaque méthode. Mais ça n'est pas pertinent. Tu parlais de temps d'exécution. Pour moi, au-delà de la consomation CPU, c'est la *seule* mesure qui soit facile à obtenir sur toute plateforme, mais surtout significative pour l'utilisateur. Si tu veux tester les performances de tes applis sur différentes plateformes, il te suffit donc de leur faire te retourner (par socket, ou n'importe quel autre moyen) le temps d'exécution sur telle ou telle plateforme.
-- Nicolas Delsaux Tu as des poils qui te poussent partout sur le corps ? Ta bibliothèque est plus grande à l'intérieur qu'à l'extérieur ? Et pire que tout, tu commences toutes tes phrases par Oo en les terminant par kkkk ? Pas de doute, tu te transformes en bibliothécaire de l'université invisible.
Le 18.11 2003, Sebastien Devaux s'est levé et s'est dit : "tiens, si
j'écrivais aux mecs de fr.comp.lang.java ?"
Bonjour le groupe,
Quel est le meilleur moyen depuis un programme Java d'avoir une idée de
la consommation CPU utilisée pour éxecuter un bout de code : une mesure
du temps écoulé ne me suffit pas car j'ai besoin d'un indice qui prend
en compte la puissance disponible. Y a-t-il moyen d'avoir par exemple le
nombre de bytecode executé suite à l'invocation d'une méthode
quelconque ?
Tu peux ouvrir le fichier .class avec un quelconque éditeur de bytecode
(comme par exemple BCEL ou autres), qui va te permettre depuis ton code
Java de manipuler le bytecode de tes fichiers .class, mais aussi de
connaître le nombre d'instructions de chaque méthode. Mais ça n'est pas
pertinent.
Tu parlais de temps d'exécution. Pour moi, au-delà de la consomation CPU,
c'est la *seule* mesure qui soit facile à obtenir sur toute plateforme,
mais surtout significative pour l'utilisateur.
Si tu veux tester les performances de tes applis sur différentes
plateformes, il te suffit donc de leur faire te retourner (par socket, ou
n'importe quel autre moyen) le temps d'exécution sur telle ou telle
plateforme.
--
Nicolas Delsaux
Tu as des poils qui te poussent partout sur le corps ?
Ta bibliothèque est plus grande à l'intérieur qu'à l'extérieur ?
Et pire que tout, tu commences toutes tes phrases par Oo en les terminant
par kkkk ?
Pas de doute, tu te transformes en bibliothécaire de l'université
invisible.
Le 18.11 2003, Sebastien Devaux s'est levé et s'est dit : "tiens, si j'écrivais aux mecs de fr.comp.lang.java ?"
Bonjour le groupe,
Quel est le meilleur moyen depuis un programme Java d'avoir une idée de la consommation CPU utilisée pour éxecuter un bout de code : une mesure du temps écoulé ne me suffit pas car j'ai besoin d'un indice qui prend en compte la puissance disponible. Y a-t-il moyen d'avoir par exemple le nombre de bytecode executé suite à l'invocation d'une méthode quelconque ?
Tu peux ouvrir le fichier .class avec un quelconque éditeur de bytecode (comme par exemple BCEL ou autres), qui va te permettre depuis ton code Java de manipuler le bytecode de tes fichiers .class, mais aussi de connaître le nombre d'instructions de chaque méthode. Mais ça n'est pas pertinent. Tu parlais de temps d'exécution. Pour moi, au-delà de la consomation CPU, c'est la *seule* mesure qui soit facile à obtenir sur toute plateforme, mais surtout significative pour l'utilisateur. Si tu veux tester les performances de tes applis sur différentes plateformes, il te suffit donc de leur faire te retourner (par socket, ou n'importe quel autre moyen) le temps d'exécution sur telle ou telle plateforme.
-- Nicolas Delsaux Tu as des poils qui te poussent partout sur le corps ? Ta bibliothèque est plus grande à l'intérieur qu'à l'extérieur ? Et pire que tout, tu commences toutes tes phrases par Oo en les terminant par kkkk ? Pas de doute, tu te transformes en bibliothécaire de l'université invisible.
Sebastien Devaux
Nicolas Delsaux wrote:
Tu peux ouvrir le fichier .class avec un quelconque éditeur de bytecode (comme par exemple BCEL ou autres), qui va te permettre depuis ton code Java de manipuler le bytecode de tes fichiers .class, mais aussi de connaître le nombre d'instructions de chaque méthode. Mais ça n'est pas pertinent. C'est bien ce que je craignais. Je pensais qu'on pouvait avoir quelque
chose qui ressemble à ce qui est affiché par l'émulateur j2me quand le programme se termine, parmi les infos affiché, il y a le nombre de bytecode affiché. J'en déduis que pour faire cela il faut lancer la JVM en C avec un mode debug particulier pour après récuperer les infos. J'avais espoir de pouvoir le faire directement dans un prog java.
Tu parlais de temps d'exécution. Pour moi, au-delà de la consomation CPU, c'est la *seule* mesure qui soit facile à obtenir sur toute plateforme, mais surtout significative pour l'utilisateur. Oui le temps est la bonne mesure si la quantité de travaille accomplie
est connue.
Si tu veux tester les performances de tes applis sur différentes plateformes, il te suffit donc de leur faire te retourner (par socket, ou n'importe quel autre moyen) le temps d'exécution sur telle ou telle plateforme. En fait je déploie une espèce de conteneur qui lance des applets sans
vraiment savoir exactement ce qu'elles font. Je voudrais quand une applet se termine avoir une idée de la puissance dont a pu bénéficier l'applet (on part du principe que l'applet n'est pas interactive et qu'elle n'est pas en sommeil en attente de je ne sais quoi...). Le ratio nb_bytecode_executé/temps_execution aurait été un très bon estimateur qui a surtout l'avantage d'avoir un sens équivalent qur toutes les plateforme.
Je vais sans doute me rabattre sur un thread idle avec un compteur dans mon conteneur pour essayer de jouer aux devinettes... -- Sébastien Devaux //, http://www.freesoftware.fsf.org/gsp/ http://www.freesoftware.fsf.org/naja/
Nicolas Delsaux wrote:
Tu peux ouvrir le fichier .class avec un quelconque éditeur de bytecode
(comme par exemple BCEL ou autres), qui va te permettre depuis ton code
Java de manipuler le bytecode de tes fichiers .class, mais aussi de
connaître le nombre d'instructions de chaque méthode. Mais ça n'est pas
pertinent.
C'est bien ce que je craignais. Je pensais qu'on pouvait avoir quelque
chose qui ressemble à ce qui est affiché par l'émulateur j2me quand le
programme se termine, parmi les infos affiché, il y a le nombre de
bytecode affiché. J'en déduis que pour faire cela il faut lancer la JVM
en C avec un mode debug particulier pour après récuperer les infos.
J'avais espoir de pouvoir le faire directement dans un prog java.
Tu parlais de temps d'exécution. Pour moi, au-delà de la consomation CPU,
c'est la *seule* mesure qui soit facile à obtenir sur toute plateforme,
mais surtout significative pour l'utilisateur.
Oui le temps est la bonne mesure si la quantité de travaille accomplie
est connue.
Si tu veux tester les performances de tes applis sur différentes
plateformes, il te suffit donc de leur faire te retourner (par socket, ou
n'importe quel autre moyen) le temps d'exécution sur telle ou telle
plateforme.
En fait je déploie une espèce de conteneur qui lance des applets sans
vraiment savoir exactement ce qu'elles font. Je voudrais quand une
applet se termine avoir une idée de la puissance dont a pu bénéficier
l'applet (on part du principe que l'applet n'est pas interactive et
qu'elle n'est pas en sommeil en attente de je ne sais quoi...). Le ratio
nb_bytecode_executé/temps_execution aurait été un très bon estimateur
qui a surtout l'avantage d'avoir un sens équivalent qur toutes les
plateforme.
Je vais sans doute me rabattre sur un thread idle avec un compteur dans
mon conteneur pour essayer de jouer aux devinettes...
--
Sébastien Devaux <sebastien.devaux@laposte.net>
\//, http://www.freesoftware.fsf.org/gsp/
http://www.freesoftware.fsf.org/naja/
Tu peux ouvrir le fichier .class avec un quelconque éditeur de bytecode (comme par exemple BCEL ou autres), qui va te permettre depuis ton code Java de manipuler le bytecode de tes fichiers .class, mais aussi de connaître le nombre d'instructions de chaque méthode. Mais ça n'est pas pertinent. C'est bien ce que je craignais. Je pensais qu'on pouvait avoir quelque
chose qui ressemble à ce qui est affiché par l'émulateur j2me quand le programme se termine, parmi les infos affiché, il y a le nombre de bytecode affiché. J'en déduis que pour faire cela il faut lancer la JVM en C avec un mode debug particulier pour après récuperer les infos. J'avais espoir de pouvoir le faire directement dans un prog java.
Tu parlais de temps d'exécution. Pour moi, au-delà de la consomation CPU, c'est la *seule* mesure qui soit facile à obtenir sur toute plateforme, mais surtout significative pour l'utilisateur. Oui le temps est la bonne mesure si la quantité de travaille accomplie
est connue.
Si tu veux tester les performances de tes applis sur différentes plateformes, il te suffit donc de leur faire te retourner (par socket, ou n'importe quel autre moyen) le temps d'exécution sur telle ou telle plateforme. En fait je déploie une espèce de conteneur qui lance des applets sans
vraiment savoir exactement ce qu'elles font. Je voudrais quand une applet se termine avoir une idée de la puissance dont a pu bénéficier l'applet (on part du principe que l'applet n'est pas interactive et qu'elle n'est pas en sommeil en attente de je ne sais quoi...). Le ratio nb_bytecode_executé/temps_execution aurait été un très bon estimateur qui a surtout l'avantage d'avoir un sens équivalent qur toutes les plateforme.
Je vais sans doute me rabattre sur un thread idle avec un compteur dans mon conteneur pour essayer de jouer aux devinettes... -- Sébastien Devaux //, http://www.freesoftware.fsf.org/gsp/ http://www.freesoftware.fsf.org/naja/
