Pourquoi VisualVM Sampler ne fournit pas d'informations complètes sur la charge du processeur (exécution du temps de la méthode)?
Le problème est: VisualVM de l'échantillonneur affiche l'arborescence des appels par le temps. Pour certains de la méthode de l'échantillonneur affiche uniquement les "temps" donc je ne vois pas ce qui rend cette méthode lente. Voici un exemple.
Comment puis-je augmenter la profondeur de profilage?
source d'informationauteur fedor.belov
Vous devez vous connecter pour publier un commentaire.
Malheureusement échantillonnage profileurs sont plutôt limitées quand il s'agit de profilage en profondeur en raison d'un certain nombre de raisons:
Échantillonneurs sont limitées par la période d'échantillonnage: Par exemple, VisualVM a actuellement une période d'échantillonnage de 20ms. Les processeurs modernes peuvent exécuter plusieurs millions d'instructions en ce temps - certainement plus que suffisant pour appeler plusieurs courts de méthodes et de retour.
Alors que la solution la plus évidente serait de diminuer la période d'échantillonnage, elle permettrait également d'accroître l'impact de la profiler sur votre demande, présenter un bel exemple de l' le principe d'incertitude.
Échantillonneurs sont facilement confondus par le code en ligne: à la Fois la JVM et que tout bon compilateur inline trivial et/ou fréquemment appelé à des méthodes, ainsi, l'incorporation de leur code dans le code appelant. Les profileurs d'échantillonnage ont aucun moyen de savoir quelles sont les parties de chaque méthode appartiennent en fait à elle et qui appartiennent à inline appels.
Dans le cas de VisualVM temps comprend en fait le temps d'exécution de la méthode et tout inline code.
Échantillonneurs peuvent se confondre par une avancée de la VM: Par exemple, dans moderne JVM implémentations de méthodes n'ont pas une représentation stable. Imaginez par exemple la méthode suivante:
Lorsque la JVM commence
B()
est interprété directement à partir de la pseudo-code binaire, prenant ainsi un peu de temps ce qui le rend visible à l'échantillonneur. Puis, après un moment, la JVM décide queB()
est un bon candidat pour l'optimisation et le compile en code natif, ce qui rend beaucoup plus rapide. Et après encore un autre moment, la JVM peut décider de l'inclure l'appel àB()
à intégrer son code dansA()
.Au mieux, un profileur d'échantillonnage indiquera le coût de ceux qui s'exécute en premier et ensuite le coût de toutes les exécutions ultérieures seront inclus dans le temps passé par l'appelant. Cela, malheureusement, peut confondre un développeur inexpérimenté en sous-estimer le coût de la méthode qui a été insérée.
Au pire, ce coût peut être attribué à un frère ou une sœur d'appel, plutôt que de l'appelant. Par exemple, je suis actuellement en train de profilage d'une application à l'aide de VisualVM, où un point d'accès semble à la
ArrayList.size()
méthode. Dans mon implémentation Java de la méthode est un simple champ de lecture que toute JVM devrait rapidement en ligne. Pourtant, le testeur affiche comme l'un des principaux temps du consommateur, en ignorant complètement un tas de proximitéHashMap
appels qui sont évidemment beaucoup plus cher.La seule façon d'éviter ces faiblesses est l'utilisation d'une instrumentation profiler, plutôt que d'un échantillonnage. Instrumentant profileurs, tel que celui fourni par le Profiler onglet VisualVM essentiellement d'enregistrer chaque et chaque méthode d'entrée et de sortie dans le code sélectionné. Malheureusement, instrumentant profileurs ont plutôt un impact lourd sur le profilé de code:
Ils insèrent leur code de surveillance autour de chaque méthode, qui change complètement la façon d'une méthode est traitée par la JVM. Même un simple champ de getter/setter ne peuvent pas être intégrées en plus en raison de la code supplémentaire, donc de biaiser les résultats. Le profileur essaie de tenir compte de ces changements, mais il n'est pas toujours couronnée de succès.
Ils causent massive ralentissements pour le profilé de code, ce qui les rend totalement inadaptés pour la surveillance des applications complètes.
Pour ces raisons instrumentant profileurs sont pour la plupart adapté pour analyser les points chauds qui ont déjà été détectés en utilisant une autre méthode comme un profileur d'échantillonnage. En instrumentant seulement un ensemble de classes et/ou les méthodes qu'il est possible de restreindre le profilage des effets secondaires à des parties spécifiques d'une application.
Il n'y a rien de mal dans l'exemple. Il semble que
updateInfoInDirection()
appelsnew SequenceInfo()
etSequenceInfo.next()
. 'Temps' signifie que le temps est passé dans le code des méthodes (la méthodeupdateInfoInDirection()
est sur le bas de la pile au moment de la thread de l'échantillon a été prélevé).