Basic usage¶

Let’s work with a simple test case:

function myfunc()A=rand(100,100,200)maximum(A)end

It’s a good idea to first run the code you intend to profile at least once (unless you want to profile Julia’s JIT-compiler):

julia>myfunc()# run once to force compilation

Now we’re ready to profile this function:

julia>@profilemyfunc()

To see the profiling results, there is a graphical browser available, but here we’ll use the text-based display that comes with the standard library:

julia>Profile.print()23client.jl;_start;line:37323client.jl;run_repl;line:16623client.jl;eval_user_input;line:9123profile.jl;anonymous;line:148none;myfunc;line:28dSFMT.jl;dsfmt_gv_fill_array_close_open!;line:12815none;myfunc;line:32reduce.jl;max;line:352reduce.jl;max;line:3611reduce.jl;max;line:37

Each line of this display represents a particular spot (line number) in the code. Indentation is used to indicate the nested sequence of function calls, with more-indented lines being deeper in the sequence of calls. In each line, the first “field” indicates the number of backtraces (samples) taken at this line or in any functions executed by this line. The second field is the file name, followed by a semicolon; the third is the function name followed by a semicolon, and the fourth is the line number. Note that the specific line numbers may change as Julia’s code changes; if you want to follow along, it’s best to run this example yourself.

In this example, we can see that the top level is client.jl‘s _start function. This is the first Julia function that gets called when you launch julia. If you examine line 373 of client.jl, you’ll see that (at the time of this writing) it calls run_repl, mentioned on the second line. This in turn calls eval_user_input. These are the functions in client.jl that interpret what you type at the REPL, and since we’re working interactively these functions were invoked when we entered @profilemyfunc(). The next line reflects actions taken in the @profile macro.

The first line shows that 23 backtraces were taken at line 373 of client.jl, but it’s not that this line was “expensive” on its own: the second line reveals that all 23 of these backtraces were actually triggered inside its call to run_repl, and so on. To find out which operations are actually taking the time, we need to look deeper in the call chain.

The first “important” line in this output is this one:

8none;myfunc;line:2

none refers to the fact that we defined myfunc in the REPL, rather than putting it in a file; if we had used a file, this would show the file name. Line 2 of myfunc() contains the call to rand, and there were 8 (out of 23) backtraces that occurred at this line. Below that, you can see a call to dsfmt_gv_fill_array_close_open! inside dSFMT.jl. You might be surprised not to see the rand function listed explicitly: that’s because rand is inlined, and hence doesn’t appear in the backtraces.

A little further down, you see:

15none;myfunc;line:3

Line 3 of myfunc contains the call to max, and there were 15 (out of 23) backtraces taken here. Below that, you can see the specific places in base/reduce.jl that carry out the time-consuming operations in the max function for this type of input data.

Overall, we can tentatively conclude that finding the maximum element is approximately twice as expensive as generating the random numbers. We could increase our confidence in this result by collecting more samples:

julia>@profile(fori=1:100;myfunc();end)julia>Profile.print()3121client.jl;_start;line:3733121client.jl;run_repl;line:1663121client.jl;eval_user_input;line:913121profile.jl;anonymous;line:1848none;myfunc;line:2842dSFMT.jl;dsfmt_gv_fill_array_close_open!;line:1281510none;myfunc;line:374reduce.jl;max;line:35122reduce.jl;max;line:361314reduce.jl;max;line:37

In general, if you have N samples collected at a line, you can expect an uncertainty on the order of sqrt(N) (barring other sources of noise, like how busy the computer is with other tasks). The major exception to this rule is garbage-collection, which runs infrequently but tends to be quite expensive. (Since julia’s garbage collector is written in C, such events can be detected using the C=true output mode described below, or by using ProfileView.)

This illustrates the default “tree” dump; an alternative is the “flat” dump, which accumulates counts independent of their nesting:

julia>Profile.print(format=:flat)CountFileFunctionLine3121client.jl_start3733121client.jleval_user_input913121client.jlrun_repl166842dSFMT.jldsfmt_gv_fill_array_close_open!128848nonemyfunc21510nonemyfunc33121profile.jlanonymous174reduce.jlmax35122reduce.jlmax361314reduce.jlmax37

If your code has recursion, one potentially-confusing point is that a line in a “child” function can accumulate more counts than there are total backtraces. Consider the following function definitions:

dumbsum(n::Integer)=n==1?1:1+dumbsum(n-1)dumbsum3()=dumbsum(3)

If you were to profile dumbsum3, and a backtrace was taken while it was executing dumbsum(1), the backtrace would look like this:

dumbsum3dumbsum(3)dumbsum(2)dumbsum(1)

Consequently, this child function gets 3 counts, even though the parent only gets one. The “tree” representation makes this much clearer, and for this reason (among others) is probably the most useful way to view the results.

Accumulation and clearing¶

Results from @profile accumulate in a buffer; if you run multiple pieces of code under @profile, then Profile.print() will show you the combined results. This can be very useful, but sometimes you want to start fresh; you can do so with Profile.clear().

Options for controlling the display of profile results¶

Profile.print() has more options than we’ve described so far. Let’s see the full declaration:

function print(io::IO=STDOUT,data=fetch();format=:tree,C=false,combine=true,cols=tty_cols())

Let’s discuss these arguments in order:

• The first argument allows you to save the results to a file, but the default is to print to STDOUT (the console).

• The second argument contains the data you want to analyze; by default that is obtained from Profile.fetch(), which pulls out the backtraces from a pre-allocated buffer. For example, if you want to profile the profiler, you could say:

  data=copy(Profile.fetch())Profile.clear()@profileProfile.print(STDOUT,data)# Prints the previous resultsProfile.print()# Prints results from Profile.print()

• The first keyword argument, format, was introduced above. The possible choices are :tree and :flat.

• C, if set to true, allows you to see even the calls to C code. Try running the introductory example with Profile.print(C=true). This can be extremely helpful in deciding whether it’s Julia code or C code that is causing a bottleneck; setting C=true also improves the interpretability of the nesting, at the cost of longer profile dumps.

• Some lines of code contain multiple operations; for example, s+=A[i] contains both an array reference (A[i]) and a sum operation. These correspond to different lines in the generated machine code, and hence there may be two or more different addresses captured during backtraces on this line. combine=true lumps them together, and is probably what you typically want, but you can generate an output separately for each unique instruction pointer with combine=false.

• cols allows you to control the number of columns that you are willing to use for display. When the text would be wider than the display, you might see output like this:

  33inference.jl;abstract_call;line:64533inference.jl;abstract_call;line:64533...rence.jl;abstract_call_gf;line:56733...nce.jl;typeinf;line:1201+15...nce.jl;...t_interpret;line:900+35...ence.jl;abstract_eval;line:758+45...ence.jl;...ct_eval_call;line:733+65...ence.jl;abstract_call;line:645

  File/function names are sometimes truncated (with ...), and indentation is truncated with a +n at the beginning, where n is the number of extra spaces that would have been inserted, had there been room. If you want a complete profile of deeply-nested code, often a good idea is to save to a file and use a very wide cols setting:

  s=open("/tmp/prof.txt","w")Profile.print(s,cols=500)close(s)

Configuration¶

@profile just accumulates backtraces, and the analysis happens when you call Profile.print(). For a long-running computation, it’s entirely possible that the pre-allocated buffer for storing backtraces will be filled. If that happens, the backtraces stop but your computation continues. As a consequence, you may miss some important profiling data (you will get a warning when that happens).

You can obtain and configure the relevant parameters this way:

Profile.init()# returns the current settingsProfile.init(n,delay)Profile.init(delay=0.01)

n is the total number of instruction pointers you can store, with a default value of 10^6. If your typical backtrace is 20 instruction pointers, then you can collect 50000 backtraces, which suggests a statistical uncertainty of less than 1%. This may be good enough for most applications.

Consequently, you are more likely to need to modify delay, expressed in seconds, which sets the amount of time that Julia gets between snapshots to perform the requested computations. A very long-running job might not need frequent backtraces. The default setting is delay=0.001. Of course, you can decrease the delay as well as increase it; however, the overhead of profiling grows once the delay becomes similar to the amount of time needed to take a backtrace (~30 microseconds on the author’s laptop).