Performance difference between local Ref (allocated once) and a local float

[amitmurthy]

Timing differences between summing into a local Ref (allocated once) vs a local float.

No difference when adding 1.0 a billion times
Ref takes 50% more time when adding rand() a billion times

julia> function foo1(n)
           a = Ref(0.0)
           for i in 1:10^n
               a.x += 1.0
           end
           a.x
       end
foo1 (generic function with 1 method)

julia> function bar1(n)
           a = 0.0
           for i in 1:10^n
               a += 1.0
           end
           a
       end
bar1 (generic function with 1 method)

julia> function foorand(n)
           a = Ref(0.0)
           for i in 1:10^n
               a.x += rand()
           end
           a.x
       end
foorand (generic function with 1 method)

julia> function barrand(n)
           a = 0.0
           for i in 1:10^n
               a += rand()
           end
           a
       end
barrand (generic function with 1 method)

julia> foo1(1); bar1(1); foorand(1); barrand(1);

julia> @time foo1(9)
  0.942448 seconds (6 allocations: 192 bytes)
1.0e9

julia> @time bar1(9)
  0.960316 seconds (5 allocations: 176 bytes)
1.0e9

julia> @time foorand(9)
  3.020439 seconds (6 allocations: 192 bytes)
4.9999308850923723e8

julia> @time barrand(9)
  1.964119 seconds (5 allocations: 176 bytes)
4.999952968904752e8

[yuyichao]

I believe this is #16969 and #15369. We are just hitting the cache harder and running more instructions for an otherwise very cheap loop. Note that foo1 and bar1 has the same performance because LLVM can prove that it is legal to delay the store to the ref until the end of the loop since there's no synchronization point in the loop.