Thanks for taking a look! I opened an issue
here https://github.com/JuliaLang/julia/issues/9272
On Monday, December 8, 2014 3:36:05 PM UTC+11, Stefan Karpinski wrote:
>
> I did spend some time poking at this but I couldn't figure out what the
> problem is on 0.3. You may want to file an issue and you may get the
> attention of some other people who may figure it out faster than me.
>
> On Sun, Dec 7, 2014 at 9:47 PM, Will Dobbie <wdo...@gmail.com
> <javascript:>> wrote:
>
>> I tested it on 0.4-dev+1310 and it fixed the allocations in the example
>> above. But my real program was still allocating at the same spot. It seems
>> to be a different issue unrelated to immutables. I've boiled it down to the
>> example below. It's a little contrived as my real aim is to write to memory
>> not allocated by Julia. It seems to be something to do with accessing
>> arrays directly versus through a field? I've tried splitting it up into
>> separate type-annotated functions but there was no change.
>>
>> module immtest
>>
>> type Container
>> array::Array{Float32}
>> size::Uint32
>> end
>>
>> function runtest(reps)
>> dst = resize!(Float32[], 100_000)
>> src = resize!(Float32[], 10)
>> container = Container(dst, 1000)
>>
>> @time begin
>> for i=1:reps
>> # This does not cause allocation
>> # copy!(dst, container.size+1, src, 1)
>>
>> # This does
>> copy!(container.array, container.size+1, src, 1)
>> end
>> end
>> end
>>
>> runtest(10_000_000)
>>
>> end
>>
>>
>>
>>
>> On Sunday, December 7, 2014 3:06:52 AM UTC+11, Stefan Karpinski wrote:
>>>
>>> I can reproduce this on 0.3. Looking into it.
>>>
>>> On Sat, Dec 6, 2014 at 7:04 AM, Tim Holy <tim....@gmail.com> wrote:
>>>
>>>> Curiously, I don't even see it on my copy of julia 0.3.
>>>>
>>>> Will, one tip: julia optimizes within functions. Anytime you see
>>>> something
>>>> weird like this, try to separate allocation and operation into two
>>>> separate
>>>> functions. That way, the function that's performing lots of computation
>>>> will
>>>> receive a concrete type as an input, and be well-optimized.
>>>>
>>>> --Tim
>>>>
>>>> On Friday, December 05, 2014 06:38:28 PM John Myles White wrote:
>>>> > I think this might be a problem with Julia 0.3. I see it on Julia
>>>> 0.3, but
>>>> > not on the development branch for Julia 0.4.
>>>> >
>>>> > — John
>>>> >
>>>> > On Dec 5, 2014, at 6:27 PM, Will Dobbie <wdo...@gmail.com> wrote:
>>>> > > Hi,
>>>> > >
>>>> > > I have a program which copies elements between two arrays of
>>>> immutables in
>>>> > > a tight loop. The sizes of the arrays never change. I've been
>>>> struggling
>>>> > > to get it to avoid spending a large chunk of its time in the garbage
>>>> > > collector. I have an example of what I mean below.
>>>> > >
>>>> > > With arrays of Int64 I get:
>>>> > > elapsed time: 0.164429425 seconds (0 bytes allocated)
>>>> > >
>>>> > > With arrays of an immutable the same size as Int64 I get:
>>>> > > elapsed time: 1.421834146 seconds (320000000 bytes allocated,
>>>> 15.97% gc
>>>> > > time)
>>>> > >
>>>> > > My understanding was arrays of immutables should behave like arrays
>>>> of
>>>> > > structs in C and not require heap allocation. Is there a way I can
>>>> > > achieve that? I'm using Julia 0.3.3.
>>>> > >
>>>> > > Thanks,
>>>> > > Will
>>>> > >
>>>> > >
>>>> > >
>>>> > > module immtest
>>>> > >
>>>> > > immutable Vec2
>>>> > >
>>>> > > x::Float32
>>>> > > y::Float32
>>>> > >
>>>> > > end
>>>> > >
>>>> > > # typealias element_type Vec2 # Results in allocation
>>>> in the loop
>>>> below
>>>> > > typealias element_type Int64 # Does not cause
>>>> allocation
>>>> > >
>>>> > > function runtest(reps)
>>>> > >
>>>> > > dst = resize!(element_type[], 100_000)
>>>> > > src = resize!(element_type[], 10)
>>>> > >
>>>> > > @time begin
>>>> > >
>>>> > > for i=1:reps
>>>> > >
>>>> > > copy!(dst, 1000, src, 1, length(src))
>>>> > > # dst[1000:1009] = src # same
>>>> performance as above
>>>> > >
>>>> > > end
>>>> > >
>>>> > > end
>>>> > >
>>>> > > end
>>>> > >
>>>> > > runtest(10_000_000)
>>>> > >
>>>> > > end
>>>>
>>>>
>>>
>
