Projects

Tue May 9 19:53:00 GMT 2000

"Boehm, Hans" <hans_boehm@hp.com> writes:
> > > However, I believe that collecting a 1 GB heap is an entirely
> > > different problem than collecting a 1 MB heap. I hate to see the
> > > application that actually has an entire 1GB of heap space active at
> > > once.
> > 
> > It's pretty scary. It makes the class overhead pretty trivial, I'd
> > gladly trade memory for performance.
> > 
> I would actually guess that an Itanium or Alpha box with 2GB physical memory
> and a 1 GB live heap should work OK, at least if we can get the incremental
> GC mode going with gcj. 30MB live on a machine 30 times slower was
> tolerable, and I don't see any reason this shouldn't scale if you have 64
> bit pointers. With 32 bit pointers, I would guess that many applications
> will still be OK, but some won't. There's an old SP&E paper by Wentworth
> that discusses conservative garbage collection with effectively 16 bit
> pointers and a 64K heap, i.e. with every bit pattern a valid pointer.
>
Actually, I have some numbers here with the GC I'm working on. On a
400MHZ PowerPC, a full scan of 900MB of used data takes around 150
seconds when using 10% of the CPU (10ms every 100 ms, this is a
concurrent incremental collector) with a representative mutator
running concurrently. This is really not too bad. If finalization is
used, This means two GC cycles and some finalization work, but even 6
or 7 minutes is not too bad. We were planning on 15 minutes for a GC
cycle, so we were pleasantly surprised. Finishing the final
collection (last root set scan) does take longer than 10ms generally,
though, due to the large number of class files that have to be
scanned as part of the root set (hint, hint...).
I don't have any numbers on Boehm here because I couldn't get the
incremental collector working well on a Power PC, but it would be
interesting if there were some numbers available.
But the scary part is keeping the mutator under control. An
application with a very active mutator would be a big problem for an
incremental collector in this memory space. We have been trying to
write our application to be nice to the GC, so we should be ok, but
it's still scary, because if we hit a full mark and sweep, that's
around 15 seconds we are out, which is too long for our application.
Corey