TimerOutputs

TimerOutputs is a small Julia package that is used to generate formatted output from timings made in different sections of a program. It's main functionality is the @timeit macro, similar to the @time macro in Base except one also assigns a label to the code section being timed. Multiple calls to code sections with the same label (and in the same "scope") will accumulate the data for that label. After the program has executed, it is possible to print a nicely formatted table presenting how much time, allocations and number of calls were made in each section. The output can be customized as to only show the things you are interested in.

If you find this package useful please give it a star. I like stars and it also helps me know where my development time is best spent.

Example output

An example of the output (used in a finite element simulation) is shown below

 ───────────────────────────────────────────────────────────────────────────────
                                        Time                   Allocations
                                ──────────────────────   ───────────────────────
        Tot / % measured:            6.89s / 97.8%           5.20GiB / 85.0%

 Section                ncalls     time   %tot     avg     alloc   %tot      avg
 ───────────────────────────────────────────────────────────────────────────────
 assemble                    6    3.27s  48.6%   545ms   3.65GiB  82.7%   624MiB
   inner assemble         240k    1.92s  28.4%  7.98μs   3.14GiB  71.1%  13.7KiB
 linear solve                5    2.73s  40.5%   546ms    108MiB  2.39%  21.6MiB
 create sparse matrix        6    658ms  9.77%   110ms    662MiB  14.6%   110MiB
 export                      1   78.4ms  1.16%  78.4ms   13.1MiB  0.29%  13.1MiB
 ───────────────────────────────────────────────────────────────────────────────

The first line shows the total (wall) time passed and allocations made since the start of the timer as well as the percentage of those totals spent inside timed sections. The following lines shows data for all the timed sections. The section label is shown first followed by the number of calls made to that section. Finally, the total time elapsed or allocations made in that section are shown together with the percentage of the total in that section and the average (time / allocations per call).

Usage

The easiest way to show how the package work is with a few examples of timing sections.

using TimerOutputs

# Create a TimerOutput, this is the main type that keeps track of everything.
const to = TimerOutput()

# Time a section code with the label "sleep" to the `TimerOutput` named "to"
@timeit to "sleep" sleep(0.02)

# Create a function to later time
rands() = rand(10^7)

# Time the function, @timeit returns the value being evaluated, just like Base @time
rand_vals = @timeit to "randoms" rands();

# Nested sections (sections with same name are not accumulated
# if they have different parents)
function time_test()
    @timeit to "nest 1" begin
        sleep(0.1)
        # 3 calls to the same label
        @timeit to "level 2.1" sleep(0.03)
        @timeit to "level 2.1" sleep(0.03)
        @timeit to "level 2.1" sleep(0.03)
        @timeit to "level 2.2" sleep(0.2)
    end
    @timeit to "nest 2" begin
        @timeit to "level 2.1" sleep(0.3)
        @timeit to "level 2.2" sleep(0.4)
    end
end

time_test()

# exception safe
function i_will_throw()
    @timeit to "throwing" begin
        sleep(0.5)
        throw(error("this is fine..."))
        print("nope")
    end
end

i_will_throw()

# Use disable_timer! to selectively turn off a timer, enable_timer! turns it on again
disable_timer!(to)
@timeit to "not recorded" sleep(0.1)
enable_timer!(to)

# Use @notimeit to disable timer and re-enable it afterwards (if it was enabled
# before)
@notimeit to time_test()

# Call to a previously used label accumulates data
for i in 1:100
    @timeit to "sleep" sleep(0.01)
end

# Can also annotate function definitions
@timeit to funcdef(x) = x

funcdef(2)

# Or to instrument an existing function:
foo(x) = x + 1
timed_foo = to(foo)
timed_foo(5)

# Print the timings in the default way
show(to)

Printing to shows a formatted table showing the number of calls, the total time spent in each section, and the percentage of the time spent in each section since to was created as well as averages (per call). Similar information is available for allocations:

 ────────────────────────────────────────────────────────────────────────
                                Time                    Allocations
                       ───────────────────────   ────────────────────────
   Tot / % measured:        7.99s /  39.1%            207MiB /  46.7%

 Section       ncalls     time    %tot     avg     alloc    %tot      avg
 ────────────────────────────────────────────────────────────────────────
 sleep            101    1.36s   43.4%  13.4ms   23.3KiB    0.0%     236B
 nest 2             1    711ms   22.8%   711ms   2.05KiB    0.0%  2.05KiB
   level 2.2        1    405ms   13.0%   405ms      144B    0.0%     144B
   level 2.1        1    306ms    9.8%   306ms      448B    0.0%     448B
 throwing           1    517ms   16.6%   517ms      912B    0.0%     912B
 nest 1             1    417ms   13.4%   417ms   2.17KiB    0.0%  2.17KiB
   level 2.2        1    202ms    6.5%   202ms      144B    0.0%     144B
   level 2.1        3    108ms    3.5%  36.0ms      432B    0.0%     144B
 randoms            1    120ms    3.8%   120ms   96.5MiB  100.0%  96.5MiB
 funcdef            1   94.4μs    0.0%  94.4μs     0.00B    0.0%    0.00B
 foo                1   1.50μs    0.0%  1.50μs     0.00B    0.0%    0.00B
 ────────────────────────────────────────────────────────────────────────

It is also possible to manually start and stop a timed section.

section = begin_timed_section!(to, "my section")
foo()
end_timed_section!(to, section)

Settings for printing:

The print_timer([io::IO = stdout], to::TimerOutput, kwargs), (or show) takes a number of keyword arguments to change the output. They are listed here:

title::String ─ title for the timer
allocations::Bool ─ show the allocation columns (default true)
sortby::Symbol ─ sort the sections according to :time (default), :ncalls, :allocations, :name or :firstexec
linechars::Symbol ─ use either :unicode (default) or :ascii to draw the horizontal lines in the table
compact::Bool ─ hide the avg column (default false)

Flattening

If sections are nested like in the example below:

to = TimerOutput()

@timeit to "nest 1" begin
    sleep(0.1)
    @timeit to "level 2.1" sleep(0.1)
    for i in 1:20; @timeit to "level 2.2" sleep(0.02); end
end
@timeit to "nest 2" begin
    for i in 1:30; @timeit to "level 2.1" sleep(0.01); end
    @timeit to "level 2.2" sleep(0.1)
end

the table is displayed as:

julia> show(to, allocations = false, compact = true)
 ────────────────────────────────────
 Section       ncalls     time   %tot
 ────────────────────────────────────
 nest 1             1    669ms  60.5%
   level 2.2       20    423ms  38.3%
   level 2.1        1    101ms  9.15%
 nest 2             1    437ms  39.5%
   level 2.1       30    335ms  30.3%
   level 2.2        1    101ms  9.16%
 ────────────────────────────────────

It is possible to flatten this timer using the TimerOutputs.flatten function that accumulates the data for all sections with identical labels:

julia> to_flatten = TimerOutputs.flatten(to);

julia> show(to_flatten; compact = true, allocations = false)
 ──────────────────────────────────
 Section     ncalls     time   %tot
 ──────────────────────────────────
 nest 1           1    669ms  60.5%
 level 2.2       21    525ms  47.5%
 nest 2           1    437ms  39.5%
 level 2.1       31    436ms  39.5%
 ──────────────────────────────────

Merging

Two or more timers can be merged using merge or merge!:

julia> to1 = TimerOutput(); to2 = TimerOutput();

julia> @timeit to1 "outer" begin
           @timeit to1 "inner" begin
                sleep(1)
           end
       end

julia> @timeit to2 "outer" begin
           sleep(1)
       end

julia> show(to1; compact=true, allocations=false)
 ────────────────────────────────
 Section   ncalls     time   %tot
 ────────────────────────────────
 outer          1    1.00s   100%
   inner        1    1.00s   100%
 ────────────────────────────────

julia> show(to2; compact=true, allocations=false)
 ────────────────────────────────
 Section   ncalls     time   %tot
 ────────────────────────────────
 outer          1    1.00s   100%
 ────────────────────────────────

julia> show(merge(to1, to2); compact=true, allocations=false)
 ────────────────────────────────
 Section   ncalls     time   %tot
 ────────────────────────────────
 outer          2    2.00s   100%
   inner        1    1.00s  50.0%
 ────────────────────────────────

Merging can be used to facilitate timing coverage throughout simple multi-threaded setups. For instance, use thread-local TimerOutput objects that are merged at custom merge points via the tree_point keyword arg, which is a vector of label strings used to navigate to the merge point in the timing tree. merge! is thread-safe via a lock.

julia> using TimerOutputs

julia> to = TimerOutput()

julia> @timeit to "1" begin
    @timeit to "1.1" sleep(0.1)
    @timeit to "1.2" sleep(0.1)
    @timeit to "1.3" sleep(0.1)
end

julia> @timeit to "2" Threads.@spawn begin
    to2 = TimerOutput()
    @timeit to2 "2.1" sleep(0.1)
    @timeit to2 "2.2" sleep(0.1)
    @timeit to2

TimerOutputs.jl

Install / Use

README