Quale profiler di memoria Python è consigliato? [chiuso]

Question

Voglio sapere l'uso della memoria della mia applicazione Python e in particolare voglio sapere quali blocchi di codice / porzioni o oggetti consumano la maggior parte della memoria. La ricerca di Google mostra che uno commerciale è Python Memory Validator (solo Windows).

E quelli open source sono PySizer e Heapy .

Non ho provato nessuno, quindi volevo sapere qual è il migliore considerando:

1. Fornisce la maggior parte dei dettagli.

2. Devo fare almeno o nessuna modifica al mio codice.

Answer 1

Heapy è abbastanza semplice da usare. Ad un certo punto del tuo codice, devi scrivere quanto segue:

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

Questo ti dà un output come questo:

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)

Puoi anche scoprire da dove vengono referenziati gli oggetti e ottenere statistiche a riguardo, ma in qualche modo i documenti su di essi sono un po 'sparsi.

Esiste anche un browser grafico, scritto in Tk.

Answer 2

Poiché nessuno lo ha menzionato, indicherò il mio modulo memory_profiler che è in grado di stampare riga per riga rapporto sull'utilizzo della memoria e funziona su Unix e Windows (necessita di psutil su quest'ultimo). L'output non è molto dettagliato ma l'obiettivo è fornire una panoramica di dove il codice sta consumando più memoria e non un'analisi esaustiva sugli oggetti allocati.

Dopo aver decorato la tua funzione con @profile ed eseguito il tuo codice con il flag -m memory_profiler stamperà un rapporto riga per riga come questo:

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

Answer 3

Raccomando Dowser . È molto facile da configurare e non sono necessarie modifiche al codice. Puoi visualizzare il numero di oggetti di ogni tipo nel tempo, visualizzare l'elenco di oggetti live, visualizzare riferimenti a oggetti live, tutto dalla semplice interfaccia web.

# 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)

Importi memdebug e chiami memdebug.start. Questo è tutto.

Non ho provato PySizer o Heapy. Gradirei le recensioni degli altri.

Aggiorna

Il codice sopra è per CherryPy 2.X , CherryPy 3.X il metodo server.quickstart è stato rimosso e engine.start non accetta il flag blocking . Quindi se stai usando CherryPy 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()

Answer 4

Prendi in considerazione la libreria objgraph (vedi http://www.lshift.net/blog/2008/11/14/tracing-python-memory-leaks per un caso d'uso di esempio) .

Answer 5

Muppy è (ancora un altro) Profiler di utilizzo della memoria per Python. Il focus di questo set di strumenti è posto sull'identificazione delle perdite di memoria.

Muppy cerca di aiutare gli sviluppatori a identificare le perdite di memoria delle applicazioni Python. Consente il rilevamento dell'utilizzo della memoria durante il runtime e l'identificazione di oggetti che perdono. Inoltre, vengono forniti strumenti che consentono di individuare l'origine degli oggetti non rilasciati.

Answer 6

Ho trovato meliae molto più funzionale di Heapy o PySizer. Se ti capita di eseguire una webapp wsgi, Dozer è un buon wrapper per middleware di Dowser

Answer 7

Sto sviluppando un profiler di memoria per Python chiamato memprof:

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

Ti consente di registrare e tracciare l'utilizzo della memoria delle tue variabili durante l'esecuzione dei metodi decorati. Devi solo importare la libreria usando:

from memprof import memprof

E decora il tuo metodo usando:

@memprof

Questo è un esempio di come appaiono i grafici:

Il progetto è ospitato in GitHub:

https://github.com/jmdana/memprof

Answer 8

Prova anche il progetto pytracemalloc che fornisce l'utilizzo della memoria per numero di riga Python.

EDIT (2014/04): ora ha una GUI Qt per analizzare le istantanee.