Sorry about that. Is there some work going into making `type` densely packed or am I way off base here?
On Tuesday, 3 March 2015 21:39:14 UTC, Mauro wrote: > > Cool. Thanks for clearing this up. > > On Tue, 2015-03-03 at 22:25, Matt Bauman <[email protected] <javascript:>> > wrote: > > Because it's not true! You were right. Only "bitstype" immutables can > be > > densely packed. > > > > You can see this by unsafely getting Julia to show you the contents as > > other types: > > > > julia> pointer_to_array(Ptr{Float64}(pointer(b)), 4) > > 4-element Array{Float64,1}: > > 2.17696e-314 > > 2.17696e-314 > > 2.17795e-314 > > 2.17795e-314 > > > > > > # That's not right, let's try them as UInt64 memory offsets: > > julia> pointer_to_array(Ptr{UInt64}(pointer(b)), 2) > > 2-element Array{UInt64,1}: > > 0x0000000106a16fb8 > > 0x0000000106a16fd0 > > > > > > # Let's try loading one of those as a pointer to type B: > > julia> x = unsafe_pointer_to_objref(Ptr{B}(ans[1])) > > B(4.0,5.0) > > > > > > # And let's change it: > > julia> x.x = 8.0 > > 8.0 > > > > > > # That change propagated to b: > > julia> b > > 2-element Array{B,1}: > > B(8.0,5.0) > > B(5.0,6.0) > > > > > > On Tuesday, March 3, 2015 at 4:14:37 PM UTC-5, Mauro wrote: > >> > >> > If you're type has only concrete field then it will be densely packed > >> > regardless of wether it's immutable or not. > >> > >> I see, sorry for the misinformation! So how comes that in below > example > >> this happens: > >> > >> julia> reinterpret(Float64,a) > >> 4-element Array{Float64,1}: > >> 4.0 > >> 5.0 > >> 5.0 > >> 6.0 > >> > >> julia> reinterpret(Float64,b) > >> ERROR: cannot reinterpret Array of type B > >> in reinterpret at array.jl:77 > >> in reinterpret at array.jl:62 > >> > >> > >> > On Tuesday, 3 March 2015 17:15:20 UTC, Mauro wrote: > >> >> > >> >> > Mauro, I do not quite understand what you're saying about densely > >> packed > >> >> > arrays, could you explain a bit more? > >> >> > >> >> Consider: > >> >> > >> >> julia> immutable A > >> >> x::Float64 > >> >> y::Float64 > >> >> end > >> >> > >> >> julia> type B > >> >> x::Float64 > >> >> y::Float64 > >> >> end > >> >> > >> >> julia> a = [A(4,5), A(5,6)] > >> >> 2-element Array{A,1}: > >> >> A(4.0,5.0) > >> >> A(5.0,6.0) > >> >> > >> >> julia> b = [B(4,5), B(5,6)] > >> >> 2-element Array{B,1}: > >> >> B(4.0,5.0) > >> >> B(5.0,6.0) > >> >> > >> >> Then in memory `a` is actually identical to: > >> >> > >> >> [4., 5., 5., 6.] > >> >> > >> >> (or > >> >> [4. 5.; 5. 6.] ) > >> >> > >> >> As Julia knows that the type of `a` is Vector{A}, it knows how to > >> >> interpret that junk of memory. Conversely, `b` is a vector of > pointers > >> >> which point to the two instances of `B`. So, working with b is > slower > >> >> than an Array{Float64,2} whereas a should be just as fast. > >> >> > >> >> > Thanks, > >> >> > Chris > >> >> > > >> >> > On Tuesday, March 3, 2015 at 11:41:53 AM UTC-5, Mauro wrote: > >> >> >> > >> >> >> > I believe if all your type fields are concrete (which they are > in > >> the > >> >> >> case > >> >> >> > of Float64), the performance should be the same as using > >> >> >> Vector{Float64}. > >> >> >> > This is really nice since you get to use code that is much more > >> >> >> > understandable like state.x instead of state[1] for no penalty. > >> >> >> > >> >> >> I think to get densely packed array the type needs to be > immutable: > >> >> >> > >> >> >> immutable StateVec > >> >> >> x::Float64 > >> >> >> y::Float64 > >> >> >> z::Float64 > >> >> >> end > >> >> >> > >> >> >> Otherwise it will be an array of pointers. > >> >> >> > >> >> > >> >> > >> > >> > >
