The Shenandoah Code

Last weekend I’ve been talking about the Shenandoah GC at FOSDEM 2014. I announced the availability of the Shenandoah source code and project pages. Until Shenandoah becomes a proper OpenJDK project, it will be hosted on IcedTea servers. We currently have:

We also filed a JEP for Shenandoah, here you can find the announcement and discussion on hotspot-gc-dev.

If you are interested in the slides that I prsented at FOSDEM, you can find them here.

Implementation-wise we’re making good progress. Concurrent evacuation is working well and support for the C1 compiler is almost done.

About Roman Kennke
JVM Hacker, Principal Software Engineer at Red Hat's OpenJDK team, Shenandoah GC project lead, Java Champion

8 Responses to The Shenandoah Code

  1. Radim Vansa says:

    I hope you’ll post more details soon… I was on Shenandoah presentation on, but a closer description of all the problems would be cool.

  2. sirinath says:

    Is it possible to aim for true pause less GC?

    Perhaps each thread could use the current execution point and trace information to determine which objects are likely to access next and let GC kick in once the possibility of access has passed. E.g. loop exit

    • Michal Warecki says:

      As far as I know SATB phase is STW and what is more important the SATB list grows proportionally to the objects mutated during the concurrent part of the marking phase.
      There are also other parallel phases but I see potential in Shenandoah when more heuristics will be applied.

  3. sirinath says:

    Also brooks pointers may take some cycles hence might have to re think this.

  4. sirinath says:

    Locally accessed objects as GC roots.

    Another this is when execution control passes over and there is an object you just accesses see if the object is GCable when last local reference to the object. Also use this as a GC root if collectable to see if any aggregated objects in the object in question is accessible.

  5. sirinath says:

    Perhaps another area is to do GC based on locality. When a loop or function exited some locally referred objects may become collectable. Once control flows forward keep sweeping the garbage left behind!

  6. sirinath says:

    Also OCaml has a pretty good GC through not parallel. Some insight can be taken by studying this.

  7. Pingback: jClarity | Shenandoah – Early findings with running PCGen

Leave a Reply

Fill in your details below or click an icon to log in: Logo

You are commenting using your account. Log Out /  Change )

Google photo

You are commenting using your Google account. Log Out /  Change )

Twitter picture

You are commenting using your Twitter account. Log Out /  Change )

Facebook photo

You are commenting using your Facebook account. Log Out /  Change )

Connecting to %s

%d bloggers like this: