Garbage Collection for Multicore Systems

Principal investigator: Richard Jones
Co-Investistigator: Fred Barnes

Project Summary

Developers are increasingly turning to languages like Java and C# for their ease of development, deployment and maintenance. Most applications for the foreseeable future will be written in languages supported by managed runtimes, running on multicore hardware. Particular benefits of managed runtimes include support for automatic dynamic memory management, or 'garbage collection' (GC) and threads. GC allows programs to recycle unused memory automatically, without error-prone programmer intervention. Threading allows a program to run different sequences of instructions in parallel; for instance, a web server might employ a separate thread for each incoming request from internet browsers.

One of the most significant recent developments for language implementers is the development of multicore processors, with the number of cores deployed in commodity platforms expected to increase significantly over the next 5 years. The complexity of the processor's access to memory has also increased, in terms of levels of memory hierarchy and in the technology interconnecting processors. However, modern runtime technology has not evolved as fast as hardware technology, and how to fully exploit hardware parallelism remains an open question.

This research asks, how can we exploit hardware parallelism, in particular by running multiple user program ('mutator') and GC threads? How can we avoid paying penalties for non-local memory access, but still benefit from multiple paths to memory? How can we take proactive advantage of locality properties? How can we minimise synchronisation between mutator and GC threads?

Today's concurrent GC techniques avoid relocating live objects, so as to minimise the need for this synchronisation, but this leads to poor use of memory with many small holes but nowhere to accommodate larger objects ('fragmentation'). The standard fragmentation solution - periodic compaction phases - has high overheads, and often lacks portability or leads to throughput slumps before mutator threads can operate at full speed again. Memory management will be a bottleneck for the next generation of increasingly thread parallel software unless the problem of high performance GC for multicore can be solved. This proposal aims to address this key problem, reconciling compaction with concurrency and performance.

Publications

• Exploring Garbage Collection with Haswell Hardware Transactional Memory. Carl G. Ritson, Tomoharu Ugawa and Richard Jones. Proceedings of the ACM SIGPLAN International Symposium on Memory Management (ISMM). ACM, June 2014. [slides]
• Reference Object Processing in On-The-Fly Garbage Collection. Tomoharu Ugawa, Richard Jones and Carl G. Ritson. Proceedings of the ACM SIGPLAN International Symposium on Memory Management (ISMM). ACM, June 2014. [slides]
• Rigorous Benchmarking in Reasonable Time. Tomas Kalibera and Richard Jones. Proceedings of the ACM SIGPLAN International Symposium on Memory Management (ISMM). ACM, June 2013.
• A Black-box Approach to Understanding Concurrency in DaCapo. Tomas Kalibera, Matthew Mole, Richard Jones and Jan Vitek. Proceedings of the ACM SIGPLAN Conference on Object-Oriented Programming, Systems, Languages and Applications (OOPSLA). ACM, 2012.
• Quantifying performance changes with effect size confidence intervals. Tomas Kalibera and Richard Jones. Technical Report 4-12, School of Computing, University of Kent, June 2012.
• The Garbage Collection Handbook: The Art of Automatic Memory Management. Richard Jones, Antony Hosking, and Eliot Moss. Chapman and Hall, January 2012.
• Repeatability, reproducibility and rigor in systems research (invited paper). Jan Vitek and Tomas Kalibera. In Proceedings of the International Conference on Embedded Software (EMSOFT), pages 182-196. ACM, October 2011.
• Handles revisited: optimising performance and memory costs in a real-time collector. Tomas Kalibera and Richard Jones. In Proceedings of the ACM SIGPLAN International Symposium on Memory Management (ISMM). ACM, June 2011.
• The locality of concurrent write barriers. Laurence Hellyer, Richard Jones, and Antony Hosking. In Jan Vitek and Doug Lea, editors, Proceedings of the International Symposium on Memory Management, pages 83-92, Toronto, Canada, June 2010. ACM.
• The locality of concurrent write barriers (extended version). Laurence Hellyer, Richard Jones, and Antony L. Hosking. Technical Report 3-10, School of Computing, University of Kent, June 2010.

The MirrorGC project is kindly supported by the EPSRC, EP/H026975/1