From: Leopold Toetsch <lt@[...].at> 
   Date: Mon, 18 Jul 2005 17:08:53 +0200

   Circular or not isn't really the problem. With generational GC you'll 
   always have the chance of tenured garbage . . .

   Now due to some other pointer store the object C becomes dead. But as 
   long as we don't scan up to generation j, we don't realize this and 
   object A stays alive.

That's true, but not my point.  I don't understand how the IGP mechanism
permits cycles to be collected at all.

   . . .

       gen n           |       gen j
       [ A ] ->  [ B ] -|-----> [ C ]
	 ^                      |
	 +----------------------+

   A circular data structure doesn't really change the picture, except, 
   when again scanning up to generation j, and we find object C being 
   alive, we'd have to restart scanning at object A, by following the 
   backreference.
   If non of A, B, or C is referenced from elsewhere, we would still delete 
   the whole reference loop.

So that means you do not use the IGP pointer to A when collecting any
generation <= j, correct?  Otherwise, I imagine you'd always decide that
A is alive, and hence B and C.

   But what if A, B, and C are all in the same generation?  You'd still
need an IGP entry, even though it's not inter-generational, in order to
handle the backpointer, but how would you then decide that it's invalid?

   >  ...  Is one-pass mark-sweep really a suitable GC algorithm for Parrot?

   I still think it's suitable yes. It's only in the above case that we 
   can't immediately cleanup A, because of the invalidation of the IGP entry.

   leo

I am willing to believe that there could be an IGP mechanism that would
perform as described, but I haven't yet heard enough to understand it
myself.  Perhaps you should save your (metaphorical) breath, and I'll
wait for a more detailed design.

					-- Bob Rogers