Rewriting byte codes

[Patrick Tullmann]

Erik wrote:
> I'd like to make some changes to Kaffe to make it simpler to do more
> precise GC.

Just for reference, so everyone's on the same page, Kaffe already does
precise walking of Java objects (see gcFuncs.c:walkObject()).  It does
not precisely walk stacks.  I believe it walks many native objects
(like jthreads, etc) conservatively.

The big problem with walking the stack isn't the Java stack as much as
the native stack.  You could walk the Java parts precisely, and the
native bits conservatively, but I don't know what you'd win anything
by doing this.

Getting Kaffe to the point where the native stacks are mapped for
precise GC would be a very significant effort.

As I understand GC trade-offs, the big win for precise GC is the
ability to update pointers and thus implement a compacting collector.
Is there something else you're hoping to get out of precise stack
walking?

Another approach to consider is to implement GC-safe points (e.g., on
method calls and backwards branches in Java code).  Then you only have
to track and update the stack maps at each safe point, this also makes
writing GC-safe native code simpler, I think.  I'm not sure if GC-safe
points would have much of an effect on the stack maps, but it might be
something to consider.

-Pat

----- ----- ---- ---  ---  --   -    -      -         -               -
Pat Tullmann                                       tullmann@cs.utah.edu
  If Gates got a dime each time Windows crashed... Oh, nevermind...