Thu, 6 Nov 1997 09:16:40 +0100
I am finishing a paper that compares the performance of several conservative
compilers (Bartlett, Boehm and CMM in various configurations).
Comments are welcome on the draft you can find at:
The comparison was based on large applications of computer algebra.
In that application we actually noticed the effect of memory leak mentioned by
Boehm due to large objects and by the feature of recognizing interior pointers.
We show that the effect can be mitigated either way: disabling interior
pointers or allocating big objects as atomic (i.e. telling the GC they contain
The configuration with interior pointer recognition and atomic big objects
seems the safest and most appropriate for Boehm collector.
We compare Boehm collector in this configuration with CMM (a mostly-copying
customizable collector for C++) and the performance is quite similar.
CMM is conservative on ambiguous roots but performs accurate object traversal
based on information derived from class declarations.
The conclusion seems to be that some information about pointers inside objects
must be supplied to a conservative collector to perform best.
The problem is to figure out which and when.
In our experience we would probably have not figured out that Boehm was
performing poorly if we did not have a comparison with CMM at hand:
we would have assumed that the application was just too big to handle.
And even then it took some effort to figure out that the reason were interior
pointers or the allocation of big integers.
CMM requires full information on pointers (which can be extracted automatically
from declarations) and can use this in several ways, in particular to
build separate heaps. And this can be an effective way to deal
with large objects (dealt poorly by GCs, as Boehm says), or temporary objects.