unnecessary(?) allocations when hashing immutable types

[mlubin]

I traced an allocation bottleneck in my code to the following issue. See the snippet below:

        - immutable Foo{T}
        -     x::T
        - end
        - 
        - function f()
      672     d = Dict{Foo{Int},Int}()
      480     d2 = Dict{Int,Int}()
        - 
   557200     sizehint!(d,20000)
   557200     sizehint!(d2,20000)
        0     for i in 1:10000
   160000         d[Foo(i)] = i+1
        0         d2[i] = i+1
        -     end
    80048     x = Array(Float64,10000)
        - 
        0     for i in 1:10000
   160000         x[i] = d[Foo(i)]
        0         x[i] += d2[i]
        -     end
        0     return x
        - end
        - 
        - f()
        - Profile.clear_malloc_data()
        - f()

It looks like the issue traces to allocations when calling object_id. Are these necessary, especially for bitstypes?

[mlubin]

FWIW, implementing

Base.hash(f::Foo{Int},h::UInt) = hash(f.x,h)

solves the allocation issue. Using this workaround gave me an order of magnitude drop in memory allocation in my code.

[JeffBezanson]

I think we are boxing the Foo in order to call the builtin jl_object_id. We should rewrite the relevant part of that function to accept a type tag and data address, so it can hash objects that are on the stack.