# Allocations reported by `@time`

I am confused by the following results of `@time`. I understand that the first call contains compilation overhead. But why is the second call allocate much more then the third?

``````julia> mutable struct M{T}; inner::T; end

julia> function doit1(o, n)
for i in 1:n
ret = o.inner
if i == n
return ret
end
end
error()
end
doit1 (generic function with 1 method)

julia> o = M(1)
M{Int64}(1)

julia> @time doit1(o, 10^1)
0.016022 seconds (15.82 k allocations: 853.133 KiB)
1

julia> @time doit1(o, 10^5)
0.004108 seconds (1.93 k allocations: 115.715 KiB)
1

julia> @time doit1(o, 10^5)
0.000243 seconds (5 allocations: 176 bytes)
1
``````

Maybe you should use

``````function doit1(o::M{T}, n) where T
...
``````

the results of `@time` can fluctuate (especially for such a ‘tiny’ function)

consider `@btime` from the BenchmarkTools.jl package, which should help you with that.

``````mutable struct M{T}; inner::T; end
function doit1(o, n)
for i in 1:n
ret = o.inner
if i == n
return ret
end
end
error()
end

o=M(1)

@time doit1(o, 10^1)
@time doit1(o, 10^5)

#the results of time fluctuate heavily
for i=1:50
@time doit1(o, 10^5)
end
#import Pkg
using BenchmarkTools

@btime doit1(o,10_000)
@btime doit1(o,100_000)
#@btime doit1(\$o,1)
#@btime doit1(\$o,10_000)
``````

The time yes, but not really the allocations.

``````julia> @time doit1(o, 10)
0.006965 seconds (21.90 k allocations: 1.196 MiB)
1

julia> @time 10^5
0.002142 seconds (1.88 k allocations: 115.072 KiB)
100000

julia> @time doit1(o, 10^5)
0.000046 seconds (5 allocations: 176 bytes)
1
``````

It seems that the allocations comes from compiling the `10^n` function for different literal `n`.

2 Likes

It seems that the allocations comes from compiling the `10^n` function for different literal `n` .

I did not understand what you said and had already wrote an answer but checked `^` documentation first, and saw:

``````  ^(x, y)

Exponentiation operator. If x is a matrix, computes matrix exponentiation.

If y is an Int literal (e.g. 2 in x^2 or -3 in x^-3), the Julia code x^y is
transformed by the compiler to Base.literal_pow(^, x, Val(y)), to enable
compile-time specialization on the value of the exponent. (As a default fallback
we have Base.literal_pow(^, x, Val(y)) = ^(x,y), where usually ^ == Base.^ unless
^ has been defined in the calling namespace.)
``````

Would never have expected this.

1 Like