Diary

1
2

# for backward compat
arrayref(inbounds::Bool, A::Array, i::Int...) = Main.Base.getindex(A, i...)

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67

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)

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20

julia> show(to) # Print the timings in the default way
────────────────────────────────────────────────────────────────────────
                            Time                    Allocations
                    ───────────────────────   ────────────────────────
Tot / % measured:        94.9s /   3.1%            115MiB /  76.6%

Section       ncalls     time    %tot     avg     alloc    %tot      avg
────────────────────────────────────────────────────────────────────────
sleep            101    1.22s   41.2%  12.1ms   12.6KiB    0.0%     128B
nest 2             1    704ms   23.7%   704ms   1.69KiB    0.0%  1.69KiB
level 2.2        1    402ms   13.5%   402ms      112B    0.0%     112B
level 2.1        1    302ms   10.2%   302ms      112B    0.0%     112B
throwing           1    503ms   16.9%   503ms      208B    0.0%     208B
nest 1             1    399ms   13.5%   399ms   2.31KiB    0.0%  2.31KiB
level 2.2        1    201ms    6.8%   201ms      112B    0.0%     112B
level 2.1        3   96.3ms    3.2%  32.1ms      640B    0.0%     213B
randoms            1    137ms    4.6%   137ms   88.1MiB  100.0%  88.1MiB
foo                1    375ns    0.0%   375ns     0.00B    0.0%    0.00B
funcdef            1    334ns    0.0%   334ns     0.00B    0.0%    0.00B
────────────────────────────────────────────────────────────────────────

1
2
3
4
5

function foo(x, y)
    # some huge function, slow to compile,
    # and you'd prefer not to compile it many times
    # for different types of x and y
end

1
2
3
4
5
6

function foo(x::X, y::Y) # X and Y are concrete types
    # some huge function, but the concrete typing ensures
    # you only compile it once
end
# This allows you to still call it with any argument types
foo(x, y) = foo(convert(X, x)::X, convert(Y, y)::Y)

 1
 2
 3
 4
 5
 6
 7
 8
 9
10

module Package

const f = Internals.f
export f

module Internals
# everything else
end

end