Esiste un modulo di profilatura ad alto livello per Python?

Question

Voglio il profilo my codice Python. Sono ben consapevole di-cProfile, e lo uso, ma è troppo di basso livello. (Per esempio, non c'è nemmeno un modo semplice per catturare il valore restituito dalla funzione sta eseguendo il profilo.)

Una delle cose che mi piacerebbe fare. Voglio prendere una funzione nel mio programma e impostarlo per essere profilato al volo durante l'esecuzione del programma

Per esempio, diciamo che ho una funzione heavy_func nel mio programma. Voglio iniziare il programma e hanno la funzione di heavy_func non profilo stesso. Ma in qualche momento durante il tempo di esecuzione del mio programma, voglio cambiare heavy_func al profilo stesso mentre è in esecuzione. (Se vi state chiedendo come posso maneggiare roba mentre il programma è in esecuzione:. Posso farlo sia dalla sonda debug o dalla shell che è integrato nella mia GUI app)

C'è un modulo già scritto che fa cose come questa? Posso scrivere io stesso, ma volevo solo chiedere prima di così non sarò reinventare la ruota.

Answer 1

ho scritto il mio proprio modulo per esso. Ho chiamato cute_profile. Ecco il codice . Qui ci sono le prove di .

Ecco il blog post che spiega come usarlo.

E 'parte della GarlicSim , quindi se si desidera utilizzarlo puoi installare garlicsim e fare from garlicsim.general_misc import cute_profile.

Se si desidera utilizzare il codice Python 3, è sufficiente installare il Python 3 fork di garlicsim .

Ecco un superata estratto del codice:

import functools

from garlicsim.general_misc import decorator_tools

from . import base_profile


def profile_ready(condition=None, off_after=True, sort=2):
    '''
    Decorator for setting a function to be ready for profiling.

    For example:

        @profile_ready()
        def f(x, y):
            do_something_long_and_complicated()

    The advantages of this over regular `cProfile` are:

     1. It doesn't interfere with the function's return value.

     2. You can set the function to be profiled *when* you want, on the fly.

    How can you set the function to be profiled? There are a few ways:

    You can set `f.profiling_on=True` for the function to be profiled on the
    next call. It will only be profiled once, unless you set
    `f.off_after=False`, and then it will be profiled every time until you set
    `f.profiling_on=False`.

    You can also set `f.condition`. You set it to a condition function taking
    as arguments the decorated function and any arguments (positional and
    keyword) that were given to the decorated function. If the condition
    function returns `True`, profiling will be on for this function call,
    `f.condition` will be reset to `None` afterwards, and profiling will be
    turned off afterwards as well. (Unless, again, `f.off_after` is set to
    `False`.)

    `sort` is an `int` specifying which column the results will be sorted by.
    '''


    def decorator(function):

        def inner(function_, *args, **kwargs):

            if decorated_function.condition is not None:

                if decorated_function.condition is True or \
                   decorated_function.condition(
                       decorated_function.original_function,
                       *args,
                       **kwargs
                       ):

                    decorated_function.profiling_on = True

            if decorated_function.profiling_on:

                if decorated_function.off_after:
                    decorated_function.profiling_on = False
                    decorated_function.condition = None

                # This line puts it in locals, weird:
                decorated_function.original_function

                base_profile.runctx(
                    'result = '
                    'decorated_function.original_function(*args, **kwargs)',
                    globals(), locals(), sort=decorated_function.sort
                )                
                return locals()['result']

            else: # decorated_function.profiling_on is False

                return decorated_function.original_function(*args, **kwargs)

        decorated_function = decorator_tools.decorator(inner, function)

        decorated_function.original_function = function
        decorated_function.profiling_on = None
        decorated_function.condition = condition
        decorated_function.off_after = off_after
        decorated_function.sort = sort

        return decorated_function

    return decorator

Answer 2

Può essere un mind-bending, ma poco questa tecnica dovrebbe aiutare a trovare i 'colli di bottiglia', è questo è ciò che si vuole fare. Sei abbastanza sicuro di ciò che di routine che si desidera mettere a fuoco. Se questo è la routine è necessario concentrarsi su, che si rivelerà il tasto destro. Se il vero problema (s) sono da qualche altra parte, che vi mostrerà dove sono.

Se si desidera un elenco noioso di ragioni per le quali, qui .