CPU-Flammendiagramme für Python

Brendan Greggs CPU-Flammendiagramme sind eine Möglichkeit, die CPU-Auslastung über einen bestimmten Zeitraum basierend auf Aufruflisten zu visualisieren.

Seine FlameGraph-Github-Projekt bietet eine sprachunabhängige Möglichkeit, diese Diagramme zu zeichnen:

Für jede Sprache benötigt FlameGraph eine Möglichkeit, Stapeleingaben in Form von Zeilen wie dieser bereitzustellen:

grandparent_func;parent_func;func 42

Dies bedeutet, dass das instrumentierte Programm als laufende Funktion beobachtet wurde funcwoher das aufgerufen wurde parent_funcdie wiederum von der Funktion der obersten Ebene aufgerufen wird grandparent_func. Es heißt, dass der Aufrufstapel 42 Mal beobachtet wurde.

Wie kann ich Stack-Informationen aus Python-Programmen sammeln und sie FlameGraph zur Verfügung stellen?

Für Bonuspunkte: Wie kann das so erweitert werden, dass sowohl der C- als auch der Python-Stack angezeigt werden, oder sogar bis zum Kernel unter Linux (ähnlich wie bei einigen Flammendiagrammen für Java und node.js auf Brendans Website)?

Vielleicht kannst du es versuchen sys.setprofiledas ist der Kern für den Standard-Python-Profiler profile und cProfile. Diese Methode setzt einen Haken zu den “call”- und “return”-Ereignissen jeder Funktion, einschließlich jener Funktionen der C-API.

Die Profilfunktion des Systems wird ähnlich wie die Trace-Funktion des Systems aufgerufen (siehe settrace()), aber sie wird nicht für jede ausgeführte Codezeile aufgerufen (nur bei Aufruf und Rückgabe, aber das Rückgabeereignis wird auch dann gemeldet, wenn eine Ausnahme aufgetreten ist einstellen).

Unten ist ein funktionierendes Beispiel:

from time import clock 
t0 = clock()

def getFun(frame):
    code = frame.f_code 
    return  code.co_name+' in '+code.co_filename+':'+str(code.co_firstlineno)

def trace_dispatch(frame, event, arg):
    if event in [ "c_call" , 'call', 'return', 'c_return']:
        t = int((clock()-t0)*1000)
        f = frame
        stack=[]
        while(f):
          stack.insert( 0,getFun(f) )
          f = f.f_back
        print event, '\t', '; '.join(stack), '; ', t

import sys
sys.setprofile(trace_dispatch)
try:
    execfile('test.py')
finally:
    sys.setprofile(None)

Test.py

def f(x):
    return x+1
def main(x):
    return f(x)
main(10)

Dies wird ausgedruckt

c_call    0
call      <module> in test.py:2 ;  1
call      <module> in test.py:2; main in test.py:5 ;  1
call      <module> in test.py:2; main in test.py:5; f in test.py:2 ;  5
return    <module> in test.py:2; main in test.py:5; f in test.py:2 ;  8
return    <module> in test.py:2; main in test.py:5 ;  11
return    <module> in test.py:2 ;  14
c_return  18
c_call    21

Sehen Sie sich eine umfassendere Profilerstellungsfunktion an hier.

C-Stapel in Python

Sie können innerhalb des Python-Interpreters nicht auf den C-Stack zugreifen. Es ist erforderlich, einen Debugger oder Profiler zu verwenden, der C/C++ unterstützt. Ich würde empfehlen gdb-python.

Pyflame unterstützt das Zeichnen von Flammendiagrammen in zwei Formaten (entweder die ‘traditionelle’ Form wie in der Frage oder die ‘seitlichen’ Flammendiagramme von Chrome unter Verwendung von Chrom selbst).

Aus https://github.com/uber/pyflame:

# Attach to PID 12345 and profile it for 1 second
pyflame -p 12345

# Attach to PID 768 and profile it for 5 seconds, sampling every 0.01 seconds
pyflame -s 5 -r 0.01 -p 768

# Run py.test against tests/, emitting sample data to prof.txt
pyflame -o prof.txt -t py.test tests/