Using #time in Julia gives surprising results - performance

Question

I am not sure why this is happening.
using Formatting: printfmt
function within(x,y)
if x * x + y * y <= 1
true
else
false
end
end
function π_estimation_error(estimated_value)
pi_known = 3.1415926535897932384626433
return abs((pi_known - estimated_value) / 100)
end
function estimate_π_1(n)
count = 0
for i = 1:n
if within(rand(), rand())
count = count + 1
end
end
pi_est = count/n*4
printfmt("n: {} π estimated {:.8f}, error {:.10f}", n, pi_est, π_estimation_error(pi_est))
end
function estimate_π_2(n)
rand_coords = rand(n, 2) .^ 2
count = sum(rand_coords[:,1] + rand_coords[:,2] .<= 1)
pi_est = count/n*4
printfmt("n: {} π estimated {:.8f}, error {:.10f}", n, pi_est, π_estimation_error(pi_est))
end
number_of_experiments = 20000000
for i = 1:10
print("1 :: ")
#time estimate_π_1(number_of_experiments)
print("2 :: ")
#time estimate_π_2(number_of_experiments)
end
What is the proper way to get consistent results? Not sure why this is happening. The allocation numbers seem way off.
1 :: n: 20000000 π estimated 3.14188540, error 0.0000029275 0.507643 seconds (1.15 M allocations: 56.432 MiB, 8.75% gc time)
2 :: n: 20000000 π estimated 3.14141280, error 0.0000017985 0.786538 seconds (1.13 M allocations: 1.100 GiB, 13.17% gc time)
1 :: n: 20000000 π estimated 3.14118120, error 0.0000041145 0.054791 seconds (181 allocations: 6.711 KiB)
2 :: n: 20000000 π estimated 3.14207560, error 0.0000048295 0.536932 seconds (196 allocations: 1.045 GiB, 14.11% gc time)
1 :: n: 20000000 π estimated 3.14119660, error 0.0000039605 0.054647 seconds (181 allocations: 6.711 KiB)
2 :: n: 20000000 π estimated 3.14154040, error 0.0000005225 0.529361 seconds (196 allocations: 1.045 GiB, 14.04% gc time)
1 :: n: 20000000 π estimated 3.14188640, error 0.0000029375 0.054321 seconds (181 allocations: 6.711 KiB)
2 :: n: 20000000 π estimated 3.14177120, error 0.0000017855 0.532848 seconds (196 allocations: 1.045 GiB, 14.01% gc time)
1 :: n: 20000000 π estimated 3.14191880, error 0.0000032615 0.055158 seconds (181 allocations: 6.711 KiB)
2 :: n: 20000000 π estimated 3.14213220, error 0.0000053955 0.524499 seconds (196 allocations: 1.045 GiB, 14.02% gc time)
1 :: n: 20000000 π estimated 3.14161380, error 0.0000002115 0.054355 seconds (181 allocations: 6.711 KiB)
2 :: n: 20000000 π estimated 3.14174220, error 0.0000014955 0.529431 seconds (196 allocations: 1.045 GiB, 14.17% gc time)
1 :: n: 20000000 π estimated 3.14178600, error 0.0000019335 0.054558 seconds (181 allocations: 6.711 KiB)
2 :: n: 20000000 π estimated 3.14152500, error 0.0000006765 0.537786 seconds (196 allocations: 1.045 GiB, 13.89% gc time)
1 :: n: 20000000 π estimated 3.14163340, error 0.0000004075 0.055921 seconds (181 allocations: 6.711 KiB)
2 :: n: 20000000 π estimated 3.14220380, error 0.0000061115 0.521758 seconds (196 allocations: 1.045 GiB, 14.19% gc time)
1 :: n: 20000000 π estimated 3.14092000, error 0.0000067265 0.054592 seconds (181 allocations: 6.711 KiB)
2 :: n: 20000000 π estimated 3.14177460, error 0.0000018195 0.527376 seconds (196 allocations: 1.045 GiB, 14.10% gc time)
1 :: n: 20000000 π estimated 3.14171780, error 0.0000012515 0.054904 seconds (181 allocations: 6.711 KiB)
2 :: n: 20000000 π estimated 3.14136040, error 0.0000023225 0.528569 seconds (196 allocations: 1.045 GiB, 14.04% gc time)
Is this happeing because some optimization kicks in?

Answer 1

I understand you are asking why the first run of a function is always much slower and allocates more memory than subsequent runs?
The reason is that Julia is compiled language - so the first time you run any function, Julia will compile it to binary code, creating binary methods corresponding to the most commonly expected input types. For any later calls of that function, Julia will see that it's already generated the binary code and just use that.