Hacker News Reader

Comment by nwalfield | Hacker News Reader

The author unfortunately doesn't understand how GC works:

> GC’s overhead relates to the total memory allocated, not just > the memory actively used in the code. Each new allocation > results in an increased time per scanning cycle. Certainly > there are many optimizations involved in a good GC to limit > this, but the fundamental relationship is still linear. As a > program uses more memory the overhead of it’s GC increases.

A GC's overhead (at least a mark and sweep collector) is proportional to the number of live objects. This is because all of the dead objects are unreachable and thus aren't scanned.

View on HN

Plain mark and sweep has to touch all currently allocated objects, it's obvious, it either has to mark the object or deallocate the object in the sweep phase.

On the other hand two-space copying GC only touches live objects.

I'm not sure how this disputes what I say about a scanning garbage collector. The number of live objects is proportional to the amount of total memory allocated.

I don't consider dead objects, where the memory is not longer used and free to be allocated, to be part of the allocated memory.

That's a confusing choice of terminology. "allocated" reads like the past-tense of "allocate"; it's natural to think "allocated" means "was allocated at some point in the past". Maybe it is correct in some technical sense, but for the casual reader "live" would be a lot clearer.

> The number of live objects is proportional to the amount of total memory allocated.

No, that's not right. The number (or ratio) of live objects depends on application behavior. According to the weak generational hypothesis, most objects die young, so a garbage collector that only touches live objects (e.g. tracing) does no work at all for the most objects.

The actual survival rate is complex and depends on application behavior, but typical well-tuned GC systems often see survival rates from young generation collections around 10%--that means that only 10% of objects ever occur any GC overhead. Those 90% of quickly dying objects do, however, take up memory and cache space until they are reclaimed. IMO that is only remaining situation where manual memory management can outperform GC by wide margins: when a program can carefully reuse recently allocated memory to keep reusing the same cache lines.

Reply on news.ycombinator.com