Keynotes
Performance optimizations in the .NET GC
In this talk we will look at a few interesting optimizations done in the .NET GC. One of the .NET GC’s principles is to separate mechanisms from policies which allows for much more dynamic tuning decisions. We will also use these optimizations to illustrate this principle.
How does the .NET GC organize its objects on the heap when processing them during various GC phases? It groups adjacent live objects into what’s called plugs and uses dead objects inbetween them, called gaps, to store necessary info to facilitate relocation. Special handling is done for pinned objects. Dead spaces inbetween pinned plugs which are threaded onto a free list can get used sooner to satisfy allocation requests by a mechanism called demotion. And we can decide if we want to make them available sooner by separating mechanisms from policies.
The GC can also make a decision whether it’s more productive to do a compacting or sweeping GC after calculating the relocation information (another example of separating mechanisms from policies). If it turns out to be a sweeping GC, the allocations done in the free list of the older generation will need to be repaired. We repair this by an UNDO field on each free list item and keeping a count on the original free list item we took off for allocation, and we only need to repair that many when threading back the items whose UNDO field was touched.
Dr. Maoni Stephens
Microsoft
USA
Maoni is the architect for the .NET Garbage Collector and has worked on it for the past 17 years. She loves to strive for efficiency for anything she deeply cares about like the GC. In her spare time, she enjoys watching animals, anime and detective/mystery TV shows.
Static compilation of JavaScript
JavaScript is particularly difficult to implement efficiently because most of its expressions have all sorts of different meanings that involve all sorts of different executions that are not distinguished by any syntactic or type annotation. The common intuition is that only JIT compilers can handle it efficiently because they can rely on heuristic-based strategies that require having the program and the data on hand. But static (AOT) compilers can speculate and use heuristics too! To demonstrate that, we propose Hopc, an AOT compiler for JavaScript, based on the following assumption:
The most likely data structure a program will use is the one for which the compiler is able to produce its best code.
Thus, contrary to most AOT compilers, Hopc does not rely on complex static analyses to optimize programs. It simply tries to generate its best code that it protects with guards. In this presentation, I will present its main optimizations and an in-depth performance analysis.
Dr. Manuel Serrano
Inria Sophia-Antipolis
France
Manuel Serrano is a researcher of INRIA, the French research institute in computer science. During all his career, he has been committed to implementing and releasing open-source software applications. First, he has created the Bigloo compiler, an optimizing compiler for the Scheme programming language that is still widely in use. For a decade, he has been focusing on creating new programming languages for the web. He first started with Hop, an extension of Scheme that enabled programmers to implement Web applications using a functional programming language. Hop, was one of the first projects to consider JavaScript as a target of another high-level programming language. Since, about two years, he allocates all his research resources to designing and developing Hop.js, a multitier extension of JavaScript.
Manuel Serrano also contributes to open-source projects. In particular, he has created and maintained for years, Flyspell.el, the Emacs on-the-fly spell checker.
Reflections on Forty Years in Garbage Collection
Around 1978 I wrote my first garbage collector, in PDP-10 assembly code, for the Clu language being developed by Barbara Liskov's group at MIT. From the 1980s to the present I've been involved with garbage collection research as one of the main threads of my work. In these reflections I try to glean what patterns I can, with hope that younger generations of researchers may find something useful in them. While I formally retired in 2020, I continue to be active in research and will offer a few thoughts about the future as well as the past.
Dr. J. Eliot B. Moss
University of Massachusetts Amherst
USA
Eliot Moss received his undergraduate and graduate degrees from the Massachusetts Institute of Technology, culminating in a Ph.D. in Computer Science in 1981, on the subject of nested transactions. He then served in the U.S. Army until 1985 when he joined the faculty of the Department of Computer Science (now the College of Information and Computer Sciences), University of Massachusetts Amherst, where he now holds the rank of Professor Emeritus, having retired in 2020. He co-directs the Architecture and Language Implementation Laboratory. Dr. Moss's research focuses on efficient implementation of modern and emerging language features on modern and future hardware. He particularly well-known for his work on garbage collection, including being co-author of the Garbage Collection Handbook, on transactions and transactional memory, and on applications of machine learning to computer systems. He is a Fellow of the ACM and of the IEEE, a co-recipient of the Dijkstra Prize in Distributed Computing in 2012, and of several "test of time" paper and software system awards. He is also an ordained Episcopal priest, a keeper of bees, and a husband and father of two adult children.
In-Cooperation
Platinum