`tracemalloc` — Trace memory allocations¶

Hinzugefügt in Version 3.4.

Das Modul tracemalloc ist ein Debugging-Werkzeug, um von Python allozierte Speicherblöcke zu verfolgen. Es liefert folgende Informationen

Traceback, wo ein Objekt alloziiert wurde
Statistiken über allozierte Speicherblöcke pro Dateiname und Zeilennummer: Gesamtgröße, Anzahl und Durchschnittsgröße der alloziierten Speicherblöcke
Berechnung der Unterschiede zwischen zwei Schnappschüssen zur Erkennung von Speicherlecks

Um die meisten von Python alloziierten Speicherblöcke zu verfolgen, sollte das Modul so früh wie möglich gestartet werden, indem die Umgebungsvariable PYTHONTRACEMALLOC auf 1 gesetzt wird, oder durch Verwendung der Kommandozeilenoption -X tracemalloc. Die Funktion tracemalloc.start() kann zur Laufzeit aufgerufen werden, um die Verfolgung von Python-Speicherallokationen zu starten.

Standardmäßig speichert eine Verfolgung eines alloziieren Speicherblocks nur den zuletzt ausgeführten Frame (1 Frame). Um beim Start 25 Frames zu speichern: setzen Sie die Umgebungsvariable PYTHONTRACEMALLOC auf 25, oder verwenden Sie die Kommandozeilenoption -X tracemalloc=25.

Beispiele¶

Anzeige der Top 10¶

Anzeige der 10 Dateien, die den meisten Speicher alloziiert haben

import tracemalloc

tracemalloc.start()

# ... run your application ...

snapshot = tracemalloc.take_snapshot()
top_stats = snapshot.statistics('lineno')

print("[ Top 10 ]")
for stat in top_stats[:10]:
    print(stat)

Beispiel für die Ausgabe der Python-Testsuite

[ Top 10 ]
<frozen importlib._bootstrap>:716: size=4855 KiB, count=39328, average=126 B
<frozen importlib._bootstrap>:284: size=521 KiB, count=3199, average=167 B
/usr/lib/python3.4/collections/__init__.py:368: size=244 KiB, count=2315, average=108 B
/usr/lib/python3.4/unittest/case.py:381: size=185 KiB, count=779, average=243 B
/usr/lib/python3.4/unittest/case.py:402: size=154 KiB, count=378, average=416 B
/usr/lib/python3.4/abc.py:133: size=88.7 KiB, count=347, average=262 B
<frozen importlib._bootstrap>:1446: size=70.4 KiB, count=911, average=79 B
<frozen importlib._bootstrap>:1454: size=52.0 KiB, count=25, average=2131 B
<string>:5: size=49.7 KiB, count=148, average=344 B
/usr/lib/python3.4/sysconfig.py:411: size=48.0 KiB, count=1, average=48.0 KiB

Wir können sehen, dass Python 4855 KiB Daten (Bytecode und Konstanten) aus Modulen geladen hat und dass das Modul collections 244 KiB alloziiert hat, um namedtuple-Typen zu erstellen.

Weitere Optionen finden Sie unter Snapshot.statistics().

Unterschiede berechnen¶

Zwei Schnappschüsse erstellen und die Unterschiede anzeigen

import tracemalloc
tracemalloc.start()
# ... start your application ...

snapshot1 = tracemalloc.take_snapshot()
# ... call the function leaking memory ...
snapshot2 = tracemalloc.take_snapshot()

top_stats = snapshot2.compare_to(snapshot1, 'lineno')

print("[ Top 10 differences ]")
for stat in top_stats[:10]:
    print(stat)

Beispiel für die Ausgabe vor und nach der Ausführung einiger Tests der Python-Testsuite

[ Top 10 differences ]
<frozen importlib._bootstrap>:716: size=8173 KiB (+4428 KiB), count=71332 (+39369), average=117 B
/usr/lib/python3.4/linecache.py:127: size=940 KiB (+940 KiB), count=8106 (+8106), average=119 B
/usr/lib/python3.4/unittest/case.py:571: size=298 KiB (+298 KiB), count=589 (+589), average=519 B
<frozen importlib._bootstrap>:284: size=1005 KiB (+166 KiB), count=7423 (+1526), average=139 B
/usr/lib/python3.4/mimetypes.py:217: size=112 KiB (+112 KiB), count=1334 (+1334), average=86 B
/usr/lib/python3.4/http/server.py:848: size=96.0 KiB (+96.0 KiB), count=1 (+1), average=96.0 KiB
/usr/lib/python3.4/inspect.py:1465: size=83.5 KiB (+83.5 KiB), count=109 (+109), average=784 B
/usr/lib/python3.4/unittest/mock.py:491: size=77.7 KiB (+77.7 KiB), count=143 (+143), average=557 B
/usr/lib/python3.4/urllib/parse.py:476: size=71.8 KiB (+71.8 KiB), count=969 (+969), average=76 B
/usr/lib/python3.4/contextlib.py:38: size=67.2 KiB (+67.2 KiB), count=126 (+126), average=546 B

Wir können sehen, dass Python 8173 KiB Moduldaten (Bytecode und Konstanten) geladen hat, und das sind 4428 KiB mehr als vor den Tests geladen wurden, als der vorherige Schnappschuss aufgenommen wurde. Ebenso hat das Modul linecache 940 KiB Python-Quellcode zwischengespeichert, um Tracebacks zu formatieren, und das alles seit dem vorherigen Schnappschuss.

Wenn das System wenig freien Speicher hat, können Schnappschüsse mit der Methode Snapshot.dump() auf die Festplatte geschrieben werden, um den Schnappschuss offline zu analysieren. Verwenden Sie dann die Methode Snapshot.load(), um den Schnappschuss neu zu laden.

Den Traceback eines Speicherblocks abrufen¶

Code zur Anzeige des Tracebacks des größten Speicherblocks

import tracemalloc

# Store 25 frames
tracemalloc.start(25)

# ... run your application ...

snapshot = tracemalloc.take_snapshot()
top_stats = snapshot.statistics('traceback')

# pick the biggest memory block
stat = top_stats[0]
print("%s memory blocks: %.1f KiB" % (stat.count, stat.size / 1024))
for line in stat.traceback.format():
    print(line)

Beispiel für die Ausgabe der Python-Testsuite (Traceback auf 25 Frames begrenzt)

903 memory blocks: 870.1 KiB
  File "<frozen importlib._bootstrap>", line 716
  File "<frozen importlib._bootstrap>", line 1036
  File "<frozen importlib._bootstrap>", line 934
  File "<frozen importlib._bootstrap>", line 1068
  File "<frozen importlib._bootstrap>", line 619
  File "<frozen importlib._bootstrap>", line 1581
  File "<frozen importlib._bootstrap>", line 1614
  File "/usr/lib/python3.4/doctest.py", line 101
    import pdb
  File "<frozen importlib._bootstrap>", line 284
  File "<frozen importlib._bootstrap>", line 938
  File "<frozen importlib._bootstrap>", line 1068
  File "<frozen importlib._bootstrap>", line 619
  File "<frozen importlib._bootstrap>", line 1581
  File "<frozen importlib._bootstrap>", line 1614
  File "/usr/lib/python3.4/test/support/__init__.py", line 1728
    import doctest
  File "/usr/lib/python3.4/test/test_pickletools.py", line 21
    support.run_doctest(pickletools)
  File "/usr/lib/python3.4/test/regrtest.py", line 1276
    test_runner()
  File "/usr/lib/python3.4/test/regrtest.py", line 976
    display_failure=not verbose)
  File "/usr/lib/python3.4/test/regrtest.py", line 761
    match_tests=ns.match_tests)
  File "/usr/lib/python3.4/test/regrtest.py", line 1563
    main()
  File "/usr/lib/python3.4/test/__main__.py", line 3
    regrtest.main_in_temp_cwd()
  File "/usr/lib/python3.4/runpy.py", line 73
    exec(code, run_globals)
  File "/usr/lib/python3.4/runpy.py", line 160
    "__main__", fname, loader, pkg_name)

Wir können sehen, dass der meiste Speicher im Modul importlib zum Laden von Daten (Bytecode und Konstanten) aus Modulen alloziiert wurde: 870.1 KiB. Der Traceback zeigt, wo importlib zuletzt Daten geladen hat: in der Zeile import pdb des Moduls doctest. Der Traceback kann sich ändern, wenn ein neues Modul geladen wird.

Pretty Top¶

Code zur Anzeige der 10 Zeilen, die den meisten Speicher alloziiert haben, mit einer schönen Ausgabe, wobei Dateien wie <frozen importlib._bootstrap> und <unknown> ignoriert werden

import linecache
import os
import tracemalloc

def display_top(snapshot, key_type='lineno', limit=10):
    snapshot = snapshot.filter_traces((
        tracemalloc.Filter(False, "<frozen importlib._bootstrap>"),
        tracemalloc.Filter(False, "<unknown>"),
    ))
    top_stats = snapshot.statistics(key_type)

    print("Top %s lines" % limit)
    for index, stat in enumerate(top_stats[:limit], 1):
        frame = stat.traceback[0]
        print("#%s: %s:%s: %.1f KiB"
              % (index, frame.filename, frame.lineno, stat.size / 1024))
        line = linecache.getline(frame.filename, frame.lineno).strip()
        if line:
            print('    %s' % line)

    other = top_stats[limit:]
    if other:
        size = sum(stat.size for stat in other)
        print("%s other: %.1f KiB" % (len(other), size / 1024))
    total = sum(stat.size for stat in top_stats)
    print("Total allocated size: %.1f KiB" % (total / 1024))

tracemalloc.start()

# ... run your application ...

snapshot = tracemalloc.take_snapshot()
display_top(snapshot)

Beispiel für die Ausgabe der Python-Testsuite

Top 10 lines
#1: Lib/base64.py:414: 419.8 KiB
    _b85chars2 = [(a + b) for a in _b85chars for b in _b85chars]
#2: Lib/base64.py:306: 419.8 KiB
    _a85chars2 = [(a + b) for a in _a85chars for b in _a85chars]
#3: collections/__init__.py:368: 293.6 KiB
    exec(class_definition, namespace)
#4: Lib/abc.py:133: 115.2 KiB
    cls = super().__new__(mcls, name, bases, namespace)
#5: unittest/case.py:574: 103.1 KiB
    testMethod()
#6: Lib/linecache.py:127: 95.4 KiB
    lines = fp.readlines()
#7: urllib/parse.py:476: 71.8 KiB
    for a in _hexdig for b in _hexdig}
#8: <string>:5: 62.0 KiB
#9: Lib/_weakrefset.py:37: 60.0 KiB
    self.data = set()
#10: Lib/base64.py:142: 59.8 KiB
    _b32tab2 = [a + b for a in _b32tab for b in _b32tab]
6220 other: 3602.8 KiB
Total allocated size: 5303.1 KiB

Weitere Optionen finden Sie unter Snapshot.statistics().

Erfassen der aktuellen und der Spitzenwerte aller verfolgten Speicherblöcke¶

Der folgende Code berechnet zwei Summen wie 0 + 1 + 2 + ... ineffizient, indem eine Liste dieser Zahlen erstellt wird. Diese Liste verbraucht vorübergehend viel Speicher. Wir können get_traced_memory() und reset_peak() verwenden, um die geringe Speichernutzung nach der Summenberechnung sowie die Spitzen-Speichernutzung während der Berechnungen zu beobachten

import tracemalloc

tracemalloc.start()

# Example code: compute a sum with a large temporary list
large_sum = sum(list(range(100000)))

first_size, first_peak = tracemalloc.get_traced_memory()

tracemalloc.reset_peak()

# Example code: compute a sum with a small temporary list
small_sum = sum(list(range(1000)))

second_size, second_peak = tracemalloc.get_traced_memory()

print(f"{first_size=}, {first_peak=}")
print(f"{second_size=}, {second_peak=}")

Ausgabe

first_size=664, first_peak=3592984
second_size=804, second_peak=29704

Die Verwendung von reset_peak() stellte sicher, dass wir den Spitzenwert während der Berechnung von small_sum genau erfassen konnten, auch wenn dieser viel kleiner ist als die gesamte Spitzen-Speichergröße seit dem Aufruf von start(). Ohne den Aufruf von reset_peak() wäre second_peak immer noch der Spitzenwert aus der Berechnung large_sum (d.h. gleich first_peak). In diesem Fall sind beide Spitzenwerte viel höher als die endgültige Speichernutzung, was darauf hindeutet, dass wir optimieren könnten (indem wir den unnötigen Aufruf von list entfernen und sum(range(...)) schreiben).

API¶

Funktionen¶

tracemalloc.clear_traces()¶

Löscht die Spuren von von Python alloziierten Speicherblöcken.

Siehe auch stop().

tracemalloc.get_object_traceback(obj)¶

Ruft den Traceback ab, an dem das Python-Objekt obj alloziert wurde. Gibt eine Traceback-Instanz zurück oder None, wenn das Modul tracemalloc keine Speicherallokationen verfolgt oder die Allokation des Objekts nicht verfolgt hat.

Siehe auch die Funktionen gc.get_referrers() und sys.getsizeof().

tracemalloc.get_traceback_limit()¶

Ruft die maximale Anzahl von Frames ab, die im Traceback einer Verfolgung gespeichert werden.

Das Modul tracemalloc muss Speicherallokationen verfolgen, um das Limit abzurufen, andernfalls wird eine Ausnahme ausgelöst.

Das Limit wird durch die Funktion start() gesetzt.

tracemalloc.get_traced_memory()¶: Ruft die aktuelle Größe und die Spitzenlast der vom Modul tracemalloc verfolgten Speicherblöcke als Tupel ab: (current: int, peak: int).

tracemalloc.reset_peak()¶

Setzt die Spitzenlast der vom Modul tracemalloc verfolgten Speicherblöcke auf die aktuelle Größe.

Tut nichts, wenn das Modul tracemalloc keine Speicherallokationen verfolgt.

Diese Funktion ändert nur die aufgezeichnete Spitzenlast und ändert oder löscht keine Spuren, im Gegensatz zu clear_traces(). Schnappschüsse, die mit take_snapshot() vor einem Aufruf von reset_peak() erstellt wurden, können sinnvoll mit Schnappschüssen verglichen werden, die nach dem Aufruf erstellt wurden.

Siehe auch get_traced_memory().

Hinzugefügt in Version 3.9.

tracemalloc.get_tracemalloc_memory()¶: Ruft die Speichernutzung in Bytes des Moduls tracemalloc ab, das zur Speicherung von Spuren von Speicherblöcken verwendet wird. Gibt eine int zurück.

tracemalloc.is_tracing()¶

True, wenn das Modul tracemalloc Python-Speicherallokationen verfolgt, andernfalls False.

Siehe auch die Funktionen start() und stop().

tracemalloc.start(nframe: int = 1)¶

Startet die Verfolgung von Python-Speicherallokationen: Installiert Hooks auf den Speicherallokatoren von Python. Gesammelte Tracebacks von Verfolgungen werden auf nframe Frames begrenzt. Standardmäßig speichert eine Verfolgung eines Speicherblocks nur den zuletzt ausgeführten Frame: das Limit ist 1. nframe muss größer oder gleich 1 sein.

Sie können immer noch die ursprüngliche Gesamtzahl der Frames, aus denen der Traceback bestand, ablesen, indem Sie das Attribut Traceback.total_nframe betrachten.

Das Speichern von mehr als 1 Frame ist nur nützlich für die Berechnung von Statistiken, die nach 'traceback' gruppiert sind, oder für die Berechnung von kumulativen Statistiken: siehe die Methoden Snapshot.compare_to() und Snapshot.statistics().

Das Speichern von mehr Frames erhöht den Speicher- und CPU-Overhead des Moduls tracemalloc. Verwenden Sie die Funktion get_tracemalloc_memory(), um zu messen, wie viel Speicher vom Modul tracemalloc verwendet wird.

Die Umgebungsvariable PYTHONTRACEMALLOC (PYTHONTRACEMALLOC=NFRAME) und die Kommandozeilenoption -X tracemalloc=NFRAME können verwendet werden, um die Verfolgung beim Start zu beginnen.

Siehe auch die Funktionen stop(), is_tracing() und get_traceback_limit().

tracemalloc.stop()¶

Stoppt die Verfolgung von Python-Speicherallokationen: Deinstalliert Hooks auf den Speicherallokatoren von Python. Löscht auch alle zuvor gesammelten Spuren von von Python alloziierten Speicherblöcken.

Rufen Sie die Funktion take_snapshot() auf, um einen Schnappschuss der Spuren zu erstellen, bevor diese gelöscht werden.

Siehe auch die Funktionen start(), is_tracing() und clear_traces().

tracemalloc.take_snapshot()¶

Erstellt einen Schnappschuss der Spuren von von Python alloziierten Speicherblöcken. Gibt eine neue Snapshot-Instanz zurück.

Der Schnappschuss enthält keine Speicherblöcke, die alloziiert wurden, bevor das Modul tracemalloc mit der Verfolgung von Speicherallokationen begonnen hat.

Tracebacks von Spuren sind auf get_traceback_limit() Frames begrenzt. Verwenden Sie den Parameter nframe der Funktion start(), um mehr Frames zu speichern.

Das Modul tracemalloc muss Speicherallokationen verfolgen, um einen Schnappschuss zu erstellen. Siehe die Funktion start().

Siehe auch die Funktion get_object_traceback().

DomainFilter¶

class tracemalloc.DomainFilter(inclusive: bool, domain: int)¶

Filtert Spuren von Speicherblöcken nach ihrem Adressraum (Domäne).

Hinzugefügt in Version 3.6.

inclusive¶

Wenn inclusive True (einschließen) ist, werden Speicherblöcke abgeglichen, die im Adressraum domain alloziert wurden.

Wenn inclusive False (ausschließen) ist, werden Speicherblöcke abgeglichen, die nicht im Adressraum domain alloziert wurden.

domain¶: Adressraum eines Speicherblocks (int). Nur-Lese-Attribut.

Filter¶

class tracemalloc.Filter(inclusive: bool, filename_pattern: str, lineno: int = None, all_frames: bool = False, domain: int = None)¶

Filter für Spuren von Speicherblöcken.

Siehe die Funktion fnmatch.fnmatch() für die Syntax von filename_pattern. Die Dateiendung '.pyc' wird durch '.py' ersetzt.

Beispiele

Filter(True, subprocess.__file__) schließt nur Spuren des Moduls subprocess ein
Filter(False, tracemalloc.__file__) schließt Spuren des Moduls tracemalloc aus
Filter(False, "<unknown>") schließt leere Tracebacks aus

Geändert in Version 3.5: Die Dateiendung '.pyo' wird nicht mehr durch '.py' ersetzt.

Geändert in Version 3.6: Attribut domain hinzugefügt.

domain¶

Adressraum eines Speicherblocks (int oder None).

tracemalloc verwendet die Domäne 0, um von Python durchgeführte Speicherallokationen zu verfolgen. C-Erweiterungen können andere Domänen verwenden, um andere Ressourcen zu verfolgen.

inclusive¶

Wenn inclusive True (einschließen) ist, werden nur Speicherblöcke abgeglichen, die in einer Datei mit einem Namen übereinstimmend mit filename_pattern an Zeilennummer lineno alloziert wurden.

Wenn inclusive False (ausschließen) ist, werden Speicherblöcke ignoriert, die in einer Datei mit einem Namen übereinstimmend mit filename_pattern an Zeilennummer lineno alloziert wurden.

lineno¶: Zeilennummer (int) des Filters. Wenn lineno None ist, stimmt der Filter mit jeder Zeilennummer überein.

filename_pattern¶: Dateinamenmuster des Filters (str). Nur-Lese-Attribut.

all_frames¶

Wenn all_frames True ist, werden alle Frames des Tracebacks überprüft. Wenn all_frames False ist, wird nur der zuletzt ausgeführte Frame überprüft.

Dieses Attribut hat keine Auswirkung, wenn das Traceback-Limit 1 ist. Siehe die Funktion get_traceback_limit() und das Attribut Snapshot.traceback_limit.

Frame¶

class tracemalloc.Frame¶

Frame eines Tracebacks.

Die Traceback-Klasse ist eine Sequenz von Frame-Instanzen.

filename¶: Dateiname (str).

lineno¶: Zeilennummer (int).

Snapshot¶

class tracemalloc.Snapshot¶

Snapshot von Traces von Speicherblöcken, die von Python alloziert wurden.

Die Funktion take_snapshot() erstellt eine Snapshot-Instanz.

compare_to(old_snapshot: Snapshot, key_type: str, cumulative: bool = False)¶

Berechnet die Unterschiede zu einem alten Snapshot. Gibt Statistiken als sortierte Liste von StatisticDiff-Instanzen zurück, gruppiert nach key_type.

Siehe die Methode Snapshot.statistics() für die Parameter key_type und cumulative.

Das Ergebnis ist sortiert von der größten zur kleinsten nach: absolutem Wert von StatisticDiff.size_diff, StatisticDiff.size, absolutem Wert von StatisticDiff.count_diff, Statistic.count und dann nach StatisticDiff.traceback.

dump(filename)¶

Schreibt den Snapshot in eine Datei.

Verwenden Sie load(), um den Snapshot neu zu laden.

filter_traces(filters)¶

Erstellt eine neue Snapshot-Instanz mit einer gefilterten traces-Sequenz. filters ist eine Liste von DomainFilter- und Filter-Instanzen. Wenn filters eine leere Liste ist, wird eine neue Snapshot-Instanz mit einer Kopie der Traces zurückgegeben.

Alle inklusiven Filter werden auf einmal angewendet. Ein Trace wird ignoriert, wenn keine inklusiven Filter ihn abgleichen. Ein Trace wird ignoriert, wenn mindestens ein exklusiver Filter ihn abgleicht.

Geändert in Version 3.6: DomainFilter-Instanzen werden jetzt auch in filters akzeptiert.

classmethod load(filename)¶

Lädt einen Snapshot aus einer Datei.

Siehe auch dump().

statistics(key_type: str, cumulative: bool = False)¶

Gibt Statistiken als sortierte Liste von Statistic-Instanzen zurück, gruppiert nach key_type.

key_type	description
`'filename'`	filename
`'lineno'`	Dateiname und Zeilennummer
`'traceback'`	traceback

Wenn cumulative auf True gesetzt ist, werden Größe und Anzahl der Speicherblöcke aller Frames des Tracebacks eines Traces kumuliert, nicht nur des zuletzt aufgetretenen Frames. Der kumulative Modus kann nur mit key_type gleich 'filename' und 'lineno' verwendet werden.

Das Ergebnis ist sortiert von der größten zur kleinsten nach: Statistic.size, Statistic.count und dann nach Statistic.traceback.

traceback_limit¶: Maximale Anzahl von Frames, die im Traceback von traces gespeichert werden: Ergebnis von get_traceback_limit() zum Zeitpunkt der Aufnahme des Snapshots.

traces¶

Traces aller von Python allozierten Speicherblöcke: Sequenz von Trace-Instanzen.

Die Sequenz hat eine undefinierte Reihenfolge. Verwenden Sie die Methode Snapshot.statistics(), um eine sortierte Liste von Statistiken zu erhalten.

Statistic¶

class tracemalloc.Statistic¶

Statistik zu Speicherallokationen.

Snapshot.statistics() gibt eine Liste von Statistic-Instanzen zurück.

Siehe auch die Klasse StatisticDiff.

count¶: Anzahl der Speicherblöcke (int).

size¶: Gesamtgröße der Speicherblöcke in Bytes (int).

traceback¶: Traceback, in dem der Speicherblock alloziert wurde, Traceback-Instanz.

StatisticDiff¶

class tracemalloc.StatisticDiff¶

Statistikdifferenz bei Speicherallokationen zwischen einer alten und einer neuen Snapshot-Instanz.

Snapshot.compare_to() gibt eine Liste von StatisticDiff-Instanzen zurück. Siehe auch die Klasse Statistic.

count¶: Anzahl der Speicherblöcke im neuen Snapshot (int): 0, wenn die Speicherblöcke im neuen Snapshot freigegeben wurden.

count_diff¶: Differenz der Anzahl der Speicherblöcke zwischen dem alten und dem neuen Snapshot (int): 0, wenn die Speicherblöcke im neuen Snapshot alloziert wurden.

size¶: Gesamtgröße der Speicherblöcke in Bytes im neuen Snapshot (int): 0, wenn die Speicherblöcke im neuen Snapshot freigegeben wurden.

size_diff¶: Differenz der Gesamtgröße der Speicherblöcke in Bytes zwischen dem alten und dem neuen Snapshot (int): 0, wenn die Speicherblöcke im neuen Snapshot alloziert wurden.

traceback¶: Traceback, in dem die Speicherblöcke alloziert wurden, Traceback-Instanz.

Trace¶

class tracemalloc.Trace¶

Trace eines Speicherblocks.

Das Attribut Snapshot.traces ist eine Sequenz von Trace-Instanzen.

Geändert in Version 3.6: Das Attribut domain wurde hinzugefügt.

domain¶

Adressraum eines Speicherblocks (int). Nur-Lese-Attribut.

tracemalloc verwendet die Domäne 0, um von Python durchgeführte Speicherallokationen zu verfolgen. C-Erweiterungen können andere Domänen verwenden, um andere Ressourcen zu verfolgen.

size¶: Größe des Speicherblocks in Bytes (int).

traceback¶: Traceback, in dem der Speicherblock alloziert wurde, Traceback-Instanz.

Traceback¶

class tracemalloc.Traceback¶

Sequenz von Frame-Instanzen, sortiert vom ältesten Frame zum neuesten Frame.

Ein Traceback enthält mindestens 1 Frame. Wenn das Modul tracemalloc keinen Frame abrufen konnte, wird der Dateiname "<unknown>" mit der Zeilennummer 0 verwendet.

Wenn ein Snapshot erstellt wird, sind die Tracebacks von Traces auf get_traceback_limit() Frames begrenzt. Siehe die Funktion take_snapshot(). Die ursprüngliche Anzahl der Frames des Tracebacks wird im Attribut Traceback.total_nframe gespeichert. Dies ermöglicht es, festzustellen, ob ein Traceback durch das Traceback-Limit gekürzt wurde.

Das Attribut Trace.traceback ist eine Instanz von Traceback.

Geändert in Version 3.7: Frames werden jetzt vom ältesten zum neuesten Frame sortiert, anstatt vom neuesten zum ältesten.

total_nframe¶: Gesamtzahl der Frames, die den Traceback vor der Kürzung gebildet haben. Dieses Attribut kann auf None gesetzt werden, wenn die Information nicht verfügbar ist.

Geändert in Version 3.9: Das Attribut Traceback.total_nframe wurde hinzugefügt.

format(limit=None, most_recent_first=False)¶

Formatiert den Traceback als Liste von Zeilen. Verwendet das Modul linecache, um Zeilen aus dem Quellcode abzurufen. Wenn limit gesetzt ist, werden die limit neuesten Frames formatiert, wenn limit positiv ist. Andernfalls werden die abs(limit) ältesten Frames formatiert. Wenn most_recent_first auf True gesetzt ist, wird die Reihenfolge der formatierten Frames umgekehrt, sodass der neueste Frame zuerst statt zuletzt zurückgegeben wird.

Ähnlich wie die Funktion traceback.format_tb(), mit dem Unterschied, dass format() keine Zeilenumbrüche enthält.

Beispiel

print("Traceback (most recent call first):")
for line in traceback:
    print(line)

Ausgabe

Traceback (most recent call first):
  File "test.py", line 9
    obj = Object()
  File "test.py", line 12
    tb = tracemalloc.get_object_traceback(f())

`tracemalloc` — Trace memory allocations¶

Beispiele¶

Anzeige der Top 10¶

Unterschiede berechnen¶

Den Traceback eines Speicherblocks abrufen¶

Pretty Top¶

Erfassen der aktuellen und der Spitzenwerte aller verfolgten Speicherblöcke¶

API¶

Funktionen¶

DomainFilter¶

Filter¶

Frame¶

Snapshot¶

Statistic¶

StatisticDiff¶

Trace¶

Traceback¶

Inhaltsverzeichnis

Vorheriges Thema

Nächstes Thema

Diese Seite

tracemalloc — Trace memory allocations¶

Beispiele¶

Anzeige der Top 10¶

Unterschiede berechnen¶

Den Traceback eines Speicherblocks abrufen¶

Pretty Top¶

Erfassen der aktuellen und der Spitzenwerte aller verfolgten Speicherblöcke¶

API¶

Funktionen¶

DomainFilter¶

Filter¶

Frame¶

Snapshot¶

Statistic¶

StatisticDiff¶

Trace¶

Traceback¶

`tracemalloc` — Trace memory allocations¶