|Possible to write compiler to Java VM? (I volunteer to summarize) email@example.com (Peter Seibel) (1996-01-17)|
|Java-Ada95 comparisons firstname.lastname@example.org (Saileshwar Krishnamurthy) (1996-01-29)|
|Re: Java-Ada95 comparisons email@example.com.HAC.COM (1996-01-30)|
|Re: Java-Ada95 comparisons firstname.lastname@example.org (1996-02-02)|
|Re: Java-Ada95 comparisons email@example.com (1996-02-09)|
|From:||firstname.lastname@example.org (Hans Boehm)|
|Date:||2 Feb 1996 09:49:43 -0500|
|Organization:||Xerox Palo Alto Research Center|
|References:||96-01-037 96-01-105 96-01-126|
email@example.com.HAC.COM (Mark Johnson) writes:
>I don't think adding garbage collection to the system would help much.
>The program still has to break the links to the "garbage" - otherwise
>there is nothing to collect. If it does that, it should look to
>deallocate the memory explicitly instead. Then garbage collection
At the risk of revisiting old arguments: (I assume we're no longer
talking about hard real-time systems, which involve different issues.)
Garbage collected systems rarely break links explicitly. Objects
usually become garbage as a result of overwritten pointers or lost
bindings as a result of procedure returns. In extremely rare cases,
there are performance reasons for explicitly clearing links. Usually
the failure to do so, only results in a fixed size, not growing, leak.
Even explicitly clearing links is much easier than explicit
deallocation for two related reasons:
1. It is a local problem. I have never seen garbage collected code
that attempted to (or needed to) clear links in a data structure it
shared with another module. In explicitly managed code, explicit
deallocation of data structures referenced from more than one place is
the heart of the problem. I clear the link to the shared data
structure when I no longer need the shared data structure. The other
module clears it's link. We don't need to agree who is last.
(Agreeing who's last can also be expensive. See
2. It is safe, and errors are easy to trace. If I mistakenly clear a
pointer, I will get a nil-pointer dereference, and I will immediately
know which pointer was mistakenly cleared. If I prematurely
deallocate an object, it may be reallocated before it's referenced
again. In that case, the fault can show up with arbitrary symptoms in
an arbitrary module in the system.
Return to the
Search the comp.compilers archives again.