Have you started your language yet? Sounds like fun… I’ve always wanted to create my own language. Another thing on the TODO list .

My language will feature concurrency ala Erlang, so I’m probably going to implement Bacon’s age-oriented on-the-fly collector. It’s far less complicated than Erlang’s segregated heaps. That is, unless I figure out a good way to exploit regions.

For who’s using regions, I pointed you to Cyclone, and the other major project I know of is the ML Kit [1]. ML Kit is being used in embedded applications actually. These are projects that statically enforce safe memory management. Regions are CS literature’s name for what are sometimes called “arenas”. Arenas are used in Apache, the major difference from regions being that safe deallocation of regions is statically checked.

VMalloc is definitely an interesting project, though I’m not a C++ fan. I’m more partial to something like Streamflow [3], which shows that a generic malloc can be just as efficient and scalable as custom allocators.

I’ve been researching all this stuff to build my own language. If you’re interested in languages, I highly recommend LTU [2]. As for my tools, I’m unfortunately stuck with C# at the moment (with an eye towards moving to F#), but if you want to pick up a new language, I highly recommend an ML, like SML or OCaml. If you’re stuck with C or C++, you should check out Felix [4].

[1] http://www.itu.dk/research/mlkit/index.php/Main_Page
[2] http://lambda-the-ultimate.org/
[3] http://www.cs.vt.edu/~scschnei/papers/ismm06.pdf
[4] http://felix.sourceforge.net/

It made me wonder if anyone’s put any of this stuff into practice yet (aside from Cyclone), and I didn’t find much. The only I did find is another research project from AT&T called vmalloc which is a C/C++ library for doing region-based memory management. Looks pretty cool actually although I’d be leary of using it in a production environment.

Makes me want to give ADA a try, although if I’m going to adopt a new language I’d like some newer language features like dynamic binding, lambas / anonymous functions, delegates, closures, etc.

I’m curious, when you’re programming, what set of languages / tools do you generally use? You seem pretty up on this stuff.

The overhead of all those increment/decrement operations is actually considerable. Bacon et al. have done some impressive research on reducing the cost of ref-counting, and they’ve even designed local cycle collection algorithms to collect cyclical data structures. I’ll just give you a list of all of Bacon’s papers, with a recommendation that you read “Efficient On The Fly Cycle Collection” [1]. It’s the most useful ref-counting GC I’ve found so far, in particular when used as an “age-oriented” collector. All of Bacon’s papers there are great reads.

I’m imagining a GC with all the boons of garbage collection (automatic handling of cycles, etc) with performance characteristics similar to ref-counting. How great would that be!?

Regions are actually better. Much better. GC involves all sorts of hidden memory and cpu overheads, like object tags and tracing, which regions completely eliminate. See [2]. If you can use regions only, your program will be more efficient in both space and time.

[1] http://www.research.ibm.com/people/d/dfb/publications.html
[2] http://www.itu.dk/~mael/mypapers/pldi2002.pdf

I am actually a big fan of reference counting (use it all the time when doing C++ via Boost’s / TR1’s smart pointers). I think most of the time garbage collection is overkill — obviously it depends on the situation, but for many of my projects the overhead incurred with a ref-count alloc / dealloc is more desirable than the constant GC tracing step.

I have seen some papers on real-time garbage collection (ie ensuring that the sweep phase completes or terminates within a guaranteed period of time), which is cool, but doesn’t alleviate the issue, infact it actually causes a slight additional decrease in performance.

At any rate, I like both GC and ref-counting; it’s just important to know when to use what.

I have to say I enjoyed the Bacon et. al paper, thanks for sending the link! After thinking about it, it makes perfect sense that incrememental GCs basically come down to ref-counting and the more conservative GCs do more tracing, but I never really thought about it until you mentioned that paper.

Also, your comments on region-based memory mangement were great. The idea of using static analysis to find the earliest deallocation point for a given alloc is very enticing! I’m imagining a GC with all the boons of garbage collection (automatic handling of cycles, etc) with performance characteristics similar to ref-counting. How great would that be!? And I had no idea about Cyclone before — a neat little language actually! I’m convinced that region-based memory management is a good way to go — even providing safe manual memory management… very nice!

As for GC itself, don’t discount ref-counting! Bacon et al. demonstrated that all GCs are actually a hybrid of tracing and ref-counting [1]. The more incremental the GC, the more ref-counting it does, the higher the throughput, the more tracing it does.

But you are correct that GCs can only conservatively approximate the liveness of data by tracing from the roots. Region-based memory management provides some hope here, as static analyses can be built to find the earliest possible deallocation point for any datum. It’s not perfect, but it’s quite good. There are even languages that provide type systems to ensure safe manual memory management, ie. that freeing a piece of memory is safe. These languages are also are built on region-based memory management. See Cyclone for instance [2].

[1] http://www.research.ibm.com/people/d/dfb/papers/Bacon04Unified.pdf
[2] http://cyclone.thelanguage.org/