Is there a high-level profiling module for Python?

Question

I want to profile my Python code. I am well-aware of cProfile, and I use it, but it's too low-level. (For example, there isn't even a straightforward way to catch the return value from the function you're profiling.)

One of the things I would like to do: I want to take a function in my program and set it to be profiled on the fly while running the program.

For example, let's say I have a function heavy_func in my program. I want to start the program and have the heavy_func function not profile itself. But sometime during the runtime of my program, I want to change heavy_func to profile itself while it's running. (If you're wondering how I can manipulate stuff while the program is running: I can do it either from the debug probe or from the shell that's integrated into my GUI app.)

Is there a module already written which does stuff like this? I can write it myself but I just wanted to ask before so I won't be reinventing the wheel.

Are you confusing profiling and debugging? Normally in profiling you're testing speed, so it would not make sense to stop things and check return values. If you're trying to debug, there are tools like pdb that help you. — Mike Axiak, Sep 22 '10 at 22:31
No, I'm not confusing profiling and debugging. I didn't say I need to check return value. I simply want the function to keep returning the value that it's returning, so the program will keep on working. But the thing is, I want to test the speed only in a certain circumstances, not all the time, and this is the reason I'm asking for this. — Ram Rachum, Sep 22 '10 at 22:41

score 1 · Answer 1 · edited May 23 '17 at 09:57

1

It may be a little mind-bending, but this technique should help you find the "bottlenecks", it that's what you want to do. You're pretty sure of what routine you want to focus on. If that's the routine you need to focus on, it will prove you right. If the real problem(s) are somewhere else, it will show you where they are.

If you want a tedious list of reasons why, look here.

edited May 23 '17 at 09:57

Community

1
1

answered Sep 22 '10 at 23:59

Mike Dunlavey

40,059
14
91
135

That's a useful technique, but not what I'm looking for here. – Ram Rachum Sep 23 '10 at 00:13

Ram Rachum · Accepted Answer · 2011-02-21T20:44:22.750

I wrote my own module for it. I called it cute_profile. Here is the code. Here are the tests.

Here is the blog post explaining how to use it.

It's part of GarlicSim, so if you want to use it you can install garlicsim and do from garlicsim.general_misc import cute_profile.

If you want to use it on Python 3 code, just install the Python 3 fork of garlicsim.

Here's an outdated excerpt from the code:

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

Is there a high-level profiling module for Python?

2 Answers2