Wsrtjtyk

For style and performance considerations, I found myself comparing the following two functions. Is it possible to get equivalent performance between the following two ways to add 1 to every element in an array?

function inplaceadd1!(ar)

    ar .= ar .+ 1.

end



function add1(ar)

    return(ar .+ 1.)

end



function inplace!(ar)

    ar .= add1(ar)

end



ar1 = rand(10000)

ar2 = ar1[:]



@time inplaceadd1!(ar2)

#0.000010 seconds (4 allocations: 160 bytes)

@time inplace!(ar1)

#0.000026 seconds (6 allocations: 78.359 KiB)

Not knowing too much about compiler optimizations, to me it seems that add1 could be inlined into inplace! and the loop could be fused to achieve identical performance without extra allocations. Does this not occur?

Appreciate the insight and any recommendations.

It does not occur in your case. add1 normally returns a new array and the compiler is not able to figure out the new array is not necessary at all. Note that ! is used for style purposes and does not mean anything special to the compiler at the moment.

You should instead write your function element-wise and let the loop fusion do its work. This is a more Julia way if you are defining element-wise operations.

function inplaceadd1!(ar)

    ar .= ar .+ 1.

end



function add1(a)

    a + 1. # no `.+` here

end



function inplace!(ar)

    ar .= add1.(ar)

end

Since it is a small function, it should automatically get inlined by the compiler. You can also give a hint to the compiler by using @inline macro (annotate your function with @inline.)

@btime inplaceadd1!($ar2)

# 1.198 μs (0 allocations: 0 bytes)

@btime inplace!($ar1)

# 1.155 μs (0 allocations: 0 bytes)