Looking at those statements with the @time macro will give you some useful
information. I did the following:
julia> cl = rand(485)
485-element Array{Float64,1}:
0.186576
⋮
0.299499
julia> lagcl_precompilation_1 = [0, cl[1:end-1]]
julia> lagcl_precompilation_2 = [0.0, cl[1:end-1]]
julia> @time lagcl1 = [0, cl[1:end-1]]
elapsed time: 0.000862835 seconds (23496 bytes allocated)
julia> @time lagcl2 = [0.0, cl[1:end-1]]
elapsed time: 6.5775e-5 seconds (9696 bytes allocated)
As you can see, a lot more memory was allocated when using 0 for the first
element rather than 0.0. The reason for this is that when you use 0.0, all
elements are the same type (Float64) so Julia only needs to allocate memory
for the output once. I’m not 100% sure on exactly which approach is
actually taken for the other case, but I can imagine it would be something
like
1) allocate an array for Int64s, since the first element is Int64
2) notice that the second element is not an Int64, so allocate an array of
Any instead (i.e. an array of pointers to the actual elements)
3) fill the Any array with the data from input
4) check the type of all elements, and realize that the array type can be
tightened to Float64
5) Allocate space for a Float64 array, copy all data to it and return it
Julia is probably slightly smarter than this, so don’t take the above
description as a definitive description of how the language actually works.
However, just by looking at the first two steps you can see that if the
type of the first element is the same as the type of all other elements,
we’ll be able to skip a bunch of intermediate steps and still get the same
result: an array of Float64s. Of course, if we only allocate and copy once,
everything is going to be much faster.
Type stability
<http://docs.julialang.org/en/latest/manual/performance-tips/#write-type-stable-functions>
is one of the things that many new Julians struggle with in the beginning,
so it’s really worth reading up on. Writing type stable code is really key
to utilize all the good things about Julia’s performance.
// T
On Tuesday, August 26, 2014 3:14:54 PM UTC+2, K leo wrote:
julia> cl
> 485-element Array{Float64,1}:
> 4555.0
> 4601.0
> 4693.0
> 4678.0
> ⋮
> 5821.0
> 5854.0
> 5828.0
>
> julia> lagcl = [0, cl[1:end-1]]
> 485-element Array{Float64,1}:
> 0.0
> 4555.0
> 4601.0
> 4693.0
> ⋮
> 5842.0
> 5821.0
> 5854.0
>
> Then thinking to make the types of elements to be the same, I changed
> the above to the following (notice it is 0.0 instead of 0 at the first
> element). lagcl is only a temp array in a function that is called only
> at initialization time and lagcl[1] is actually not referenced at all.
> But the speed of my app after the initialization dropped to half.
> Nothing else was changed, and I verified it by changing 0.0 back to 0 at
> the first element. Could anyone explain?
>
> julia> lagcl = [0.0, cl[1:end-1]]
> 485-element Array{Float64,1}:
> 0.0
> 4555.0
> 4601.0
> 4693.0
> ⋮
> 5842.0
> 5821.0
> 5854.0
>
>
