Python分析 - runsnakerun输出中的列是什么？

Question

This may be really obvious but just wanted to make sure I understand what the columns are in runsnakerun.

Name, Calls, RCalls, Local, /Call, Cum, /Call, File, Line, Directory

Here are some that I think I understand

Name - name of function being called

1. Calls - number of calls?
2. File - file where the function is stored
3. Line - Line in File where the function is defined
4. Directory - directory of file with function definition

The ones I don't feel comfortable venturing a guess are the rest:

1. RCalls
2. Local
3. /Call
4. Cum
5. /Call

Thanks

Answer 1

Here is my understanding:

• RCalls number of recursive calls
• Local Total time spent on local execution (without calling another method)
• /Call Local time per call
• Cum Total cumulative time
• /Call Cumulative time per call

Answer 2

The best way to illustrate is with an example -- suppose you have the following program (stored in profileme.py, but broken into pieces for clarity):

def topfunction():
    tinyfunction()
    for i in range(100000):
        manytinyfunction()

Calls is simple -- how many times this function was called directly. Of course as you select the items on the left side, those numbers will change, reflecting the number of times the function was called by the selected function. manytinyfunction will get called 100,000 times, so calls will be 100,000. tinyfunction will get called once, so its calls will be 1.

    for i in range(10):
        recursive(100)

rcalls is similar, but it also includes calls that happened while a call was being executed. Notice for recursive that calls is only 10, but rcalls is 1010 (definition below, but it calls itself n times if its argument is n.

    alllocal()
    allcumulative()

Similarly, local includes all the time spent in the function itself, not counting calls out to other functions. Here alllocal has a large value here, but allcumulative has nothing here, since it fobs its work onto subfunction .

def tinyfunction():
    pass

def manytinyfunction():
    pass

The /Call next to the local simply breaks the local value above down per call, so manytinyfunction has a little time overall, but a very very tiny number in the local /call, since each call is really cheap.

def alllocal():
    for i in range(1000):
        for j in range(1000):
            for k in range(1000):
                pass

For alllocal the /call will be huge both for local and for cumulative, since this function is so expensive, and all the expense is local.

def allcumulative():
    for i in range(1000):
        subfunction()

def subfunction():
    for j in range(1000):
        for k in range(1000):
            pass

The /Call next to cumulative is the same as the /call for local, except that, like cumulative itself, it has the complete cost of all calls out from the function itself included. So the local /call number was tiny for allcumulative , but large for alllocal . Not so for the cumulative /call, which will be the same in both cases.

def recursive(n):
    if n > 0:
        return recursive(n-1)
    else:
        return 0

The definition for recursive is provided for completeness

if __name__=="__main__":
    topfunction()

After profiling it and running runsnake:

python -m cProfile -o profileme.out profileme.py 
runsnake profileme.out

So, notice that alllocal has a large value for both local and cumulative, where as allcumulative is sharply different. Notice that recursive is the same in both columns -- calls to yourself are counted.

The Callees button on the bottom lets you figure out what other functions the selected function is calling, while Callers lets you figure out who's calling the selected function.