Re: Compile Time Garbage Collection impossible?

the.real.doctor.zoidberg@gmail.com writes:


> Why isn't Compile-Time-Garbage-Collection feasible? Consider a Java
> compiler which produces assembly code for a specific target instead of
> Java's bytecode cenario. The objective is to use Java without the need
> for a GC or VM.
>
> I'm asking why it isn't possible because otherwise there would be at
> least one compiler to use that technique, instead of having to run a
> GC in the VM.
>
> 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?
>
> Thank you for any insight on this matter.


Consider this example:


(defparameter *data* '())


(defun main ()
    (loop
          :for cmd = (loop
                                      :with options = '(set query remove quit)
                                      :for cmd = (progn
                                                                (format *query-io* "Menu: ~{~% ~A~}~%Cmd? "
                                                                                options)
                                                                (read *query-io*))
                                      :until (member cmd options)
                                      :finally (return cmd))
          :do (case cmd
                      ((quit) (return-from main))
                      ((set) (let ((key (progn (format *query-io* "Key? ")
                                                                                  (read *query-io*)))
                                                      (value (progn (format *query-io* "Value? ")
                                                                                  (read *query-io*))))
                                              (setf (getf *data* key) value)))
                      ((query) (let ((key (progn (format *query-io* "Key? ")
                                                                                  (read *query-io*))))
                                              (format t "Key: ~A~%Value: ~A~2%"
                                                              key (getf *data* key))))
                      ((remove) (let ((key (progn (format *query-io* "Key? ")
                                                                                  (read *query-io*))))
                                              (remf *data* key))))))




You cannot know what elements of the list *data* you can garbage
collect at any time, because they came from user input and user input
directs when they are not needed anymore.




> [Local objects are usually stack allocated and freed at end of scope.
> You need GC when you do dynamic allocation, and chain stuff into lists
> and trees of data structures. -John]


Indeed.


--
__Pascal Bourguignon__ http://www.informatimago.com/

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