AA clear property

[Jonathan M Davis]

On Sunday, November 06, 2011 04:11:07 Jonathan M Davis wrote:
> On Sunday, November 06, 2011 13:39:27 Alex_Dovhal wrote:
> > "Marco Leise" <Marco.Leise at gmx.de> wrote:
> > > No way I heard of. You could delete the entries one by one. :D
> > > I guess setting all references to null is the easiest way to 'clear'
> > > an
> > > AA.
> > 
> > Thanks. I tried both of them in small benchmark. Results are
> > (1) fill_values(aa); aa = null
> > (2) fill_values(aa); aa.remove(...)
> > For both methods time1/time2 is around 35/52, with aa size 10, 100,
> > 1000,
> > and 10000.
> > Interesting enough, with aa size 1M, 10M, 100M time1/time2 is around
> > 1/1.
> > So (1) is prefered for 10-1000 elements situation i have, but it
> > allocates memory each time :( while 2 reuses it, IMHO.
> 
> 2 doesn't necessarily reuse it. It depends on what the GC does and how AAs
> are currently implemented. It's likely that in both cases, you end up with
> a fair bit of stuff which is on the heap and no longer referenced such that
> if a garbage collection cycle runs, it would be collected (or if one
> doesn't run, it just sits there still taking up memory). The only real
> difference is that _some_ of the memory will be reused with 2, whereas with
> 1, you need a whole new AA. In both cases, new memory will be required. How
> much that is depends n the current implementation of AAs. And which one is
> more likely to trigger a GC cycle probably depends on a number of factors.
> So, it wouldn't suprise me at all either way. I imagine that it's at least
> simpler for the GC to collect the memory quickly in the first case, since
> the entire AA can be collected instead of all of it, but I don't know.
> 
> AAs are a _completely_ different situation from dynamic arrays. With dynamic
> arrays, you have a clear block of contiguous memory that you're playing
> with, and it's obvious what's going to be reused if you want reuse. The
> situation is _far_ more complicated with a hash table, which is likely to
> have a fair number of items on the heap - particularly for handling each
> bucket (and there's a decent chance that each of those is a dynamic array).
> So, I very much doubt that your going to reuse much memory from an AA
> unless a GC cycle is run, regardless of whether you do #1 or #2.

And actually, I should point out that #2 would result in a _lot_ more overhead 
due to all the work done for each remove call than you get with #1. So, given 
that fact, I would actually _expect_ #1 to be faster in the general case.

- Jonathan M Davis