Welcher Python-Speicherprofiler wird empfohlen? [geschlossen]

Ich möchte die Speichernutzung meiner Python-Anwendung kennen und insbesondere wissen, welche Codeblöcke / -teile oder -objekte den meisten Speicher belegen. Die Google-Suche zeigt, dass ein kommerzieller Python Memory Validator (nur Windows) ist.

Und Open Source sind PySizer und Heapy .

Ich habe noch niemanden ausprobiert, deshalb wollte ich wissen, welches das beste ist, wenn man bedenkt:

1. Gibt die meisten Details.

2. Ich muss am wenigsten oder gar keine Änderungen an meinem Code vornehmen.

Heapy ist recht einfach zu bedienen. Irgendwann in Ihrem Code müssen Sie Folgendes schreiben:

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

Dies gibt Ihnen eine Ausgabe wie folgt:

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)

Sie können auch herausfinden, wo auf Objekte verwiesen wird, und Statistiken darüber abrufen, aber irgendwie sind die Dokumente dazu etwas spärlich.

Es gibt auch einen grafischen Browser, der in Tk geschrieben ist.

Da es niemand erwähnt hat, verweise ich auf mein Modul memory_profiler, das zeilenweise Berichte über die Speichernutzung drucken kann und unter Unix und Windows funktioniert (benötigt psutil für dieses letzte Modul). Die Ausgabe ist nicht sehr detailliert, aber das Ziel ist es, Ihnen einen Überblick darüber zu geben, wo der Code mehr Speicher verbraucht, und keine erschöpfende Analyse der zugewiesenen Objekte.

Nachdem Sie Ihre Funktion mit dekoriert @profileund Ihren Code mit dem -m memory_profilerFlag ausgeführt haben, wird ein zeilenweiser Bericht wie folgt gedruckt:

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

Ich empfehle Dowser . Es ist sehr einfach einzurichten und Sie müssen keine Änderungen an Ihrem Code vornehmen. Über die einfache Weboberfläche können Sie die Anzahl der Objekte jedes Typs im Laufe der Zeit anzeigen, eine Liste der Live-Objekte anzeigen und Verweise auf Live-Objekte anzeigen.

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

Sie importieren memdebug und rufen memdebug.start auf. Das ist alles.

Ich habe PySizer oder Heapy nicht ausprobiert. Ich würde mich über die Bewertungen anderer freuen.

AKTUALISIEREN

Der obige Code ist für CherryPy 2.X, CherryPy 3.Xdie server.quickstartMethode wurde entfernt und engine.startnimmt das blockingFlag nicht an . Also, wenn Sie verwendenCherryPy 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()

Betrachten Sie die Objektbibliothek (siehehttp://www.lshift.net/blog/2008/11/14/tracing-python-memory-leaks für einen beispielhaften Anwendungsfall).

Muppy ist (noch ein weiterer) Memory Usage Profiler für Python. Der Schwerpunkt dieses Toolset liegt auf der Identifizierung von Speicherlecks.

Muppy versucht Entwicklern dabei zu helfen, Speicherlecks in Python-Anwendungen zu identifizieren. Es ermöglicht die Verfolgung der Speichernutzung zur Laufzeit und die Identifizierung von Objekten, die undicht sind. Darüber hinaus werden Tools bereitgestellt, mit denen die Quelle nicht freigegebener Objekte gefunden werden kann.

Ich entwickle einen Speicherprofiler für Python namens memprof:

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

Sie können die Speichernutzung Ihrer Variablen während der Ausführung der dekorierten Methoden protokollieren und grafisch darstellen. Sie müssen die Bibliothek nur importieren mit:

from memprof import memprof

Und dekorieren Sie Ihre Methode mit:

@memprof

Dies ist ein Beispiel dafür, wie die Diagramme aussehen:

Das Projekt wird in GitHub gehostet:

https://github.com/jmdana/memprof

Ich fand Meliae viel funktionaler als Heapy oder PySizer. Wenn Sie zufällig eine wsgi-Webanwendung ausführen, ist Dozer ein netter Middleware-Wrapper von Dowser

Probieren Sie auch das pytracemalloc-Projekt aus , das die Speichernutzung pro Python-Zeilennummer bereitstellt.

EDIT (2014/04): Es hat jetzt eine Qt-GUI zur Analyse von Schnappschüssen.