Re: Compile Time Garbage Collection impossible?

the.real.doctor.zoidberg@gmail.com wrote:
> When a program is compiled, the compiler has to transverse all its
> code to ensure type safety (for safe languages), so what would be the
> problem in "freeing" objects after their scope, or even better, after
> the last reference in their scope?


When you have dynamically allocated data structures, determining the
scope of such an allocation is generally not so simple to determine
statically. Think of what happens when you pass such an allocated data
structure around among functions, which may put the pointer in different
  variables with different names, and even embed them inside of other
dynamic data structures. This is a difficult job even for a human,
which is why many non-trivial programs written in languages without
automatic garbage collection often have more than a few memory leaks and
related bugs. It seems to me that to determine statically when and
under what conditions a particular function will no longer require such
a dynamic memory block is in the most general case the same as trying to
figure out under what conditions that (partial recursive) function will
halt (please correct me if I am wrong; I would be glad to hear that this
isn't true). That is of course, undecidable. However, I imagine that
it must be possible to come up with some heuristics that will allow it
to make some of these determinations, but they'll likely still require a
supplementary run-time garbage collector to help with the cases they
can't catch.


There was a bit of discussion on this a couple years ago:


http://compilers.iecc.com/comparch/article/03-07-025


You may find that interesting.

Return to the comp.compilers page.
Search the comp.compilers archives again.