1. 20
  1.  

  2. 5

    Interesting! As far as production GC designs, I’d heard of HotSpot-ish generational copying collectors (good throughput but some pauses), the Go GC (full collections each time but low pauses), and fancy stuff like Azul (pauseless and compacting, but also a commercial JVM with a read barrier). Had not heard of a production concurrent generational non-copying design, nor of the retreating wavefront barrier in general.

    There are a bunch of things about it that are nonobvious to me as a nonexpert: would an advancing-wavefront barrier have just cost them some percents of efficiency here and there in extra barrier work and floating garbage, or would it be so bad that the whole design becomes untenable? More generally, which parts are just necessary because of the specifics of their VM, as opposed to essential to this kind of GC design? (The conservative stack collections and the trickiness around object reshaping sound specific to their circumstances, and like they might not be necessary if, say, a JVM implemented this design.) Is the need for tags on the objects (as opposed to bookkeeping space off to the side) fundamental to the design, or just convenient because as a JavaScript VM they already had them anyway?

    I don’t expect answers to all those of course, but it is a reminder that the space of possible designs folks explore in comp sci is much broader than what I’ve seen from exposure to a few popular systems.

    1. [Comment removed by author]

      1. 5

        Also, “non-copying” as you put it is generally referred to as “conservative”, i.e. doesn’t scan stack and/or registers

        These are two different concepts. A basic mark-sweep collector won’t move objects, but will be precise.

        1. 2

          I think folks generally agree Azul now has a different collector from HotSpot so seems reasonable (in context) to list them separately, not to detract from the joy of quibbling.

          Generally, my goal was to say that this GC makes design choices I hadn’t seen together before, and I’m now curious what a generational+concurrent+non-moving+no-read-barrier GC might look like in a different environment (JVM, CLR, or Go, say). In a practical sense the answer is I should read some papers or the GC Handbook if I want to know more, but really this was more impractical idle curiosity I was expressing (though links, etc. are welcome).