Quel profileur de mémoire Python est recommandé? [fermé]

Je veux connaître l'utilisation de la mémoire de mon application Python et je veux en particulier savoir quels blocs / portions de code ou objets consomment le plus de mémoire. La recherche Google montre qu'un commercial est le validateur de mémoire Python (Windows uniquement).

Et ceux open source sont PySizer et Heapy .

Je n'ai essayé personne, donc je voulais savoir lequel est le meilleur compte tenu:

1. Donne la plupart des détails.

2. Je dois apporter le moins ou pas de modifications à mon code.

Heapy est assez simple à utiliser. À un moment donné de votre code, vous devez écrire ce qui suit:

from guppy import hpy
h = hpy()
print(h.heap())

Cela vous donne une sortie comme celle-ci:

Partition of a set of 132527 objects. Total size = 8301532 bytes.
Index  Count   %     Size   % Cumulative  % Kind (class / dict of class)
0  35144  27  2140412  26   2140412  26 str
1  38397  29  1309020  16   3449432  42 tuple
2    530   0   739856   9   4189288  50 dict (no owner)

Vous pouvez également savoir d'où les objets sont référencés et obtenir des statistiques à ce sujet, mais d'une manière ou d'une autre, les documents à ce sujet sont un peu rares.

Il existe également un navigateur graphique, écrit en Tk.

Puisque personne ne l'a mentionné, je pointerai vers mon module memory_profiler qui est capable d'imprimer un rapport ligne par ligne de l'utilisation de la mémoire et fonctionne sous Unix et Windows (nécessite psutil sur ce dernier). La sortie n'est pas très détaillée mais le but est de vous donner un aperçu de l'endroit où le code consomme plus de mémoire et non une analyse exhaustive des objets alloués.

Après avoir décoré votre fonction avec @profileet exécuté votre code avec le -m memory_profilerdrapeau, il imprimera un rapport ligne par ligne comme ceci:

Line #    Mem usage  Increment   Line Contents
==============================================
     3                           @profile
     4      5.97 MB    0.00 MB   def my_func():
     5     13.61 MB    7.64 MB       a = [1] * (10 ** 6)
     6    166.20 MB  152.59 MB       b = [2] * (2 * 10 ** 7)
     7     13.61 MB -152.59 MB       del b
     8     13.61 MB    0.00 MB       return a

Je recommande Dowser . Il est très facile à configurer et vous n'avez besoin d'aucune modification de votre code. Vous pouvez afficher le nombre d'objets de chaque type dans le temps, afficher la liste des objets en direct, afficher les références aux objets en direct, le tout à partir de l'interface Web simple.

# memdebug.py

import cherrypy
import dowser

def start(port):
    cherrypy.tree.mount(dowser.Root())
    cherrypy.config.update({
        'environment': 'embedded',
        'server.socket_port': port
    })
    cherrypy.server.quickstart()
    cherrypy.engine.start(blocking=False)

Vous importez memdebug et appelez memdebug.start. C'est tout.

Je n'ai pas essayé PySizer ou Heapy. J'apprécierais les critiques des autres.

MISE À JOUR

Le code ci-dessus est pour CherryPy 2.X, CherryPy 3.Xla server.quickstartméthode a été supprimée et engine.startne prend pas le blockingdrapeau. Donc, si vous utilisezCherryPy 3.X

# memdebug.py

import cherrypy
import dowser

def start(port):
    cherrypy.tree.mount(dowser.Root())
    cherrypy.config.update({
        'environment': 'embedded',
        'server.socket_port': port
    })
    cherrypy.engine.start()

Considérez la bibliothèque objgraph (voirhttp://www.lshift.net/blog/2008/11/14/tracing-python-memory-leaks pour un exemple d'utilisation).

Muppy est (encore un autre) Profiler d'utilisation de la mémoire pour Python. Cet ensemble d'outils se concentre sur l'identification des fuites de mémoire.

Muppy essaie d'aider les développeurs à identifier les fuites de mémoire des applications Python. Il permet de suivre l'utilisation de la mémoire pendant l'exécution et d'identifier les objets qui fuient. De plus, des outils sont fournis qui permettent de localiser la source des objets non libérés.

Je développe un profileur de mémoire pour Python appelé memprof:

http://jmdana.github.io/memprof/

Il vous permet de consigner et de tracer l'utilisation de la mémoire de vos variables lors de l'exécution des méthodes décorées. Il vous suffit d'importer la bibliothèque en utilisant:

from memprof import memprof

Et décorez votre méthode en utilisant:

@memprof

Voici un exemple sur l'apparence des tracés:

Le projet est hébergé dans GitHub:

https://github.com/jmdana/memprof

J'ai trouvé que meliae était beaucoup plus fonctionnel que Heapy ou PySizer. S'il vous arrive d'exécuter une webapp wsgi, alors Dozer est un joli wrapper middleware de Dowser

Essayez également le projet pytracemalloc qui fournit l'utilisation de la mémoire par numéro de ligne Python.

EDIT (2014/04): Il dispose désormais d'une interface graphique Qt pour analyser les instantanés.