Perdite di memoria in Python [chiuso]

Ho uno script di lunga durata che, se lasciato funzionare abbastanza a lungo, consumerà tutta la memoria del mio sistema.

Senza entrare nei dettagli della sceneggiatura, ho due domande:

1. Ci sono delle "Best Practices" da seguire, che aiuteranno a prevenire le perdite?
2. Quali tecniche ci sono per eseguire il debug delle perdite di memoria in Python?

Dai un'occhiata a questo articolo: traccia delle perdite di memoria di Python

Inoltre, si noti che il modulo Garbage Collection in realtà può avere flag di debug impostati. Guarda la set_debugfunzione. Inoltre, guarda questo codice di Gnibbler per determinare i tipi di oggetti che sono stati creati dopo una chiamata.

Ho provato la maggior parte delle opzioni menzionate in precedenza, ma ho trovato questo pacchetto piccolo e intuitivo il migliore: pympler

È abbastanza semplice rintracciare oggetti che non sono stati raccolti in modo inutile, controlla questo piccolo esempio:

Installa il pacchetto tramite pip install pympler

from pympler.tracker import SummaryTracker
tracker = SummaryTracker()

# ... some code you want to investigate ...

tracker.print_diff()

L'output mostra tutti gli oggetti che sono stati aggiunti, oltre alla memoria che hanno consumato.

Uscita campione:

                                 types |   # objects |   total size
====================================== | =========== | ============
                                  list |        1095 |    160.78 KB
                                   str |        1093 |     66.33 KB
                                   int |         120 |      2.81 KB
                                  dict |           3 |       840 B
      frame (codename: create_summary) |           1 |       560 B
          frame (codename: print_diff) |           1 |       480 B

Questo pacchetto offre numerose altre funzionalità. Consultare la documentazione del pympler , in particolare la sezione Identificazione delle perdite di memoria .

Lasciami consigliare lo strumento mem_top che ho creato

Mi ha aiutato a risolvere un problema simile

Mostra istantaneamente i principali sospettati di perdite di memoria in un programma Python

Il modulo Tracemalloc è stato integrato come modulo integrato a partire da Python 3.4 e, a quanto pare, è disponibile anche per le versioni precedenti di Python come libreria di terze parti (non l'ho ancora testato).

Questo modulo è in grado di produrre i file e le linee precisi che hanno allocato più memoria. IMHO, queste informazioni sono infinitamente più preziose del numero di istanze allocate per ogni tipo (che finisce per essere un sacco di tuple il 99% delle volte, il che è un indizio, ma aiuta a malapena nella maggior parte dei casi).

Ti consiglio di usare tracemalloc in combinazione con pirasite . 9 volte su 10, l'esecuzione del frammento di top 10 in un guscio di pirasite fornisce informazioni e suggerimenti sufficienti per correggere la perdita entro 10 minuti. Tuttavia, se non riesci ancora a trovare la causa della perdita, la pirasite-shell in combinazione con gli altri strumenti citati in questo thread ti darà probabilmente anche altri suggerimenti. Dovresti anche dare un'occhiata a tutti gli helper extra forniti da pyrasite (come il visualizzatore di memoria).

Dovresti dare un'occhiata in particolare ai tuoi dati globali o statici (dati di lunga durata).

Quando questi dati crescono senza restrizioni, puoi anche avere problemi in Python.

Il garbage collector può solo raccogliere dati a cui non si fa più riferimento. Ma i tuoi dati statici possono collegare elementi di dati che dovrebbero essere liberati.

Un altro problema può essere rappresentato dai cicli di memoria, ma almeno in teoria il Garbage Collector dovrebbe trovare ed eliminare i cicli, almeno fintanto che non sono agganciati a dati di lunga durata.

Quali tipi di dati di lunga durata sono particolarmente problematici? Dai un'occhiata a tutti gli elenchi e dizionari: possono crescere senza limiti. Nei dizionari potresti anche non vedere il problema che si presenta da quando accedi a dicts, il numero di chiavi nel dizionario potrebbe non essere di grande visibilità per te ...

Per rilevare e individuare perdite di memoria per processi a esecuzione prolungata, ad esempio in ambienti di produzione, è ora possibile utilizzare stackimpact . Usa tracemalloc sotto. Maggiori informazioni in questo post .

Per quanto riguarda le migliori pratiche, tieni d'occhio le funzioni ricorsive. Nel mio caso mi sono imbattuto in problemi di ricorsione (dove non c'era bisogno di essere). Un esempio semplificato di ciò che stavo facendo:

def my_function():
    # lots of memory intensive operations
    # like operating on images or huge dictionaries and lists
    .....
    my_flag = True
    if my_flag:  # restart the function if a certain flag is true
        my_function()

def main():
    my_function()

operare in questo modo ricorsivo non attiverà la garbage collection e cancellerà i resti della funzione, quindi ogni volta che l'utilizzo della memoria è in continua crescita.

La mia soluzione era estrarre la chiamata ricorsiva da my_function () e fare in modo che main () gestisse quando chiamarla di nuovo. in questo modo la funzione termina in modo naturale e pulisce dopo se stessa.

def my_function():
    # lots of memory intensive operations
    # like operating on images or huge dictionaries and lists
    .....
    my_flag = True
    .....
    return my_flag

def main():
    result = my_function()
    if result:
        my_function()

Non sono sicuro di "Best Practices" per le perdite di memoria in Python, ma Python dovrebbe cancellare la propria memoria dal Garbage Collector. Quindi principalmente inizierei controllando l'elenco circolare di alcuni cortometraggi, dal momento che non saranno raccolti dal garbage collector.

Questo non è affatto un consiglio esauriente. Ma la cosa numero uno da tenere a mente quando si scrive con il pensiero di evitare future perdite di memoria (loop) è assicurarsi che tutto ciò che accetta un riferimento a una richiamata, dovrebbe memorizzare tale richiamata come riferimento debole.