Profilage en Python: Qui a appelé la fonction?

Qui peuvent ne pas répondre directement à votre question, mais va certainement aider. Si l'utilisation du profiler avec l'option --tri cumulé il va trier les fonctions en temps cumulé. Ce qui est utile pour détecter non seulement lourde, de fonctions mais la de fonctions qui les appellent.

python -m cProfile --sort cumulative myScript.py

Il y a une solution pour obtenir de l'appelant la fonction:

import inspect
print inspect.getframeinfo(inspect.currentframe().f_back)[2]

Vous pouvez ajouter autant de f_back que vous le souhaitez dans le cas où vous voulez l'appelant de l'appelant, etc
Si vous souhaitez calculer les appels fréquents que vous pouvez faire ceci:

record = {}

caller = inspect.getframeinfo(inspect.currentframe().f_back)[2]
record[caller] = record.get(caller, 0) + 1

De les imprimer ensuite par ordre de fréquence:

print sorted(record.items(), key=lambda a: a[1])

inspecter.pile() vous donnera le courant de l'appelant de la pile.

Il est possible de le faire à l'aide du générateur de profils cProfile dans la bibliothèque standard.


Dans pstats.Stats (le profiler suite) il y a la méthode print_callees (ou alternativement print_callers).

Exemple de code:

import cProfile, pstats
pr = cProfile.Profile()
pr.enable()

# ... do something ...

pr.disable()
ps = pstats.Stats(pr).strip_dirs().sort_stats('cumulative')
ps.print_callees()

Résultat sera quelque chose comme:

Function                           called...
                                       ncalls  tottime  cumtime
ElementTree.py:1517(_start_list)   ->   24093    0.048    0.124  ElementTree.py:1399(start)
                                        46429    0.015    0.041  ElementTree.py:1490(_fixtext)
                                        70522    0.015    0.015  ElementTree.py:1497(_fixname)
ElementTree.py:1527(_data)         ->   47827    0.017    0.026  ElementTree.py:1388(data)
                                        47827    0.018    0.053  ElementTree.py:1490(_fixtext)

Sur la gauche vous avez l'appelant, sur la droite, vous avez le destinataire de l'appel.


(par exemple _fixtext été appelé à partir de _data 47827 temps et de _start_list 46429 fois)

Voir aussi:

• docs.python.org/..#print_callees - appel de la hiérarchie. Groupe par l'appelant. (utilisé ci-dessus)
• docs.python.org/..#print_callers - appel de la hiérarchie. Groupe par le destinataire de l'appel.

Couple de notes:

• Votre code doit être modifié pour le présent (insérez profil consolidés).
  
  (c'est à dire pas possible de l'utiliser en ligne de commande comme python -m cProfile myscript.py. S'il est possible d'écrire un script séparé pour qu')
• Un peu non, mais strip_dirs() doit aller de l'avant sort_stats() (sinon le tri ne fonctionne pas)

Désolé, je ne suis pas familier avec Python, mais il y a un méthode générale qui fonctionne, en supposant que vous pouvez manuellement interrompre l'exécution à un moment aléatoire.

Viens de le faire, et d'afficher la pile d'appel. Il vous dira, avec une forte probabilité, ce que vous voulez savoir. Si vous voulez être plus certain, il suffit de faire plusieurs fois.

Cela fonctionne parce que la culpabilité de l'appelant doit être sur la pile d'appel pour la fraction de temps qui est perdu, ce qui les expose à votre interrompt pour que la plupart du temps, si elle est répartie sur de nombreux appels courts ou un peu longues.

REMARQUE: Ce processus est plus comme le diagnostic de la mesure. Supposons que la mauvaise appel est perdre 90% du temps. Ensuite, chaque fois que vous l'arrêter, la probabilité de 90% que la mauvaise instruction d'appel est à droite sur la pile d'appel pour vous voir, et vous serez en mesure de voir que c'est mauvais. Toutefois, si vous voulez mesurer précisément le gaspillage, c'est un autre problème. Pour cela, vous aurez besoin de beaucoup plus d'échantillons, pour voir ce qu' % d'entre eux contiennent à cet appel. Ou sinon, juste corriger le coupable appel, l'horloge de l'accélération, et qui vous dira exactement ce que le gaspillage a été.