Problems with this page?
Contact the mm-net webmaster
Last modified Tue Nov 30 10:50:07 GMT 2004
The first workshop of the UK Memory Management Network was held in the Department of Computer Science at the University of Glasgow on 5 July 2002. Its aims were to allow members of the network to meet, to listen what others are doing in this area and to exchange ideas, and to consider the directions in which to take the network. Twenty members of the Network attended the workshop, with representatives from both academia and industry (and also one visitor from Australia!).
PLEASE HELP. SEVERAL OF THESE NEED IMPROVEMENT.
Andy Cheadle described his work on providing incremental GC for 'non-stop' Haskell. The Haskell run-time evaluates expressions by reducing closures. Andy's collector removes the need for an explicit read-barrier by replacing a closure's function pointer by a pointer to a function that will first evacuate the closure to to-space, if necessary, giving pause times of 1-10ms.
Richard Jones explained the Beltway collector framework. Beltway is a new garbage collection framework that exploits and separates object age and incrementality. It groups objects in one or more increments on queues called belts, collects belts independently and collects increments on a belt in first-in-first-out order. Beltway configurations, selected by command line options, act and perform the same as semi-space, generational, and older- first collectors and encompass all previous copying collectors. The generality of Beltway enables new collectors to be designed and implemented that are robust to variations in heap size and improve total execution time over the best generational copying collectors by up to 40%, and on average by 5-10%, for small to moderate heap sizes.
Hans-Wolfgang Loidl described the Virtual Shared Memory Performance of a Parallel Graph Reducer.
Nick Barnes and Richard Brooksby introduced Ravenbrook's Memory Pool System. MPS is the product of many years work on memory management - both explicit and automatic - at Harlequin. Its key goal is orthogonality. Through abstractions of memory pool managers, pool classes and arenas, it allows multiple collectors to be employed simultaneously.
Luc Moreau described his work running the architecture group for a Grid project and suggested opportunities for memory management research in this area. www.mygrid.org.uk aims to provide personalised, extensible environments to support in-vitro experiments. Luc observed that process is important, that change happens and that discovery is personal as well as global. Support for provenance and history is important. Issues for memory management include:
Martin Trotter described GC work in IBM. IBM currently has three production JVMs (and the Jikes research VM). Their mark-sweep/compacting collector was robust and had by far the best throughput. Mostly Concurrent Collection was successful in reducing average pause times on heaps up to 5Gb. Incremental collection also constrained pause times with an acceptable overhead. In contrast to conventional wisdom, they found these collectors superior to generational GC. Weak memory ordering complicates the construction of concurrent collectors. Non-moving collectors (including real-time reference counting) still need compactors to avoid severe fragmentation problems.
Martin questioned the importance of type-accurate stack tracing. It complicated the JIT (the jsr problem) and reduced opportunities for optimisation, it increased code footprint (stack maps and larger code) and reduced code robustness (stack map errors are killers). He wondered whether a hybrid approach might be better.
Looking to the future, he saw 100Gb heaps on 64-bit platforms. The advent of more JVMs would bring challenges of management and control; system-level optimisations would be important. Hardware assistance (e.g. for write barriers) would be useful. Monitoring the health of the memory subsystem would be important. Getting the abstraction level correct was key: it would be necessary to look for trends and set goals. However, collectors are often too complex (too many knobs to turn).
Andy King drew attention to the cost of synchronising native threads before starting a collection. However, if 'thread-local' objects could be identified and segregated, the local heap of an individual thread could be collected without stopping other threads. He described two possible approaches. First, a generational collector's write barrier could be modified to copy local data to the shared heap before a pointer from a shared object to a local one was written. Unfortunately, the cost of doing this is high (although paid once per shared object). Alternatively, escape analysis could be used to identify local and shared objects and, by patching their allocation sites, to segregate objects by thread-locality. He explained how to make such an analysis and implementation robust in the face of partial knowledge of the program and dynamic class loading.
Pat Hill described a new technique for escape analysis of object-oriented programs.
Tony Printezis gave a demonstration of his and Richard Jones' GCspy: An adaptable heap visualisation framework. GCspy is an architectural framework for the collection, transmission, storage and replay of memory management behaviour. Its architecture allows easy incorporation into any memory management system: it is not limited to garbage-collected languages. It requires only small changes to the system in which it is incorporated but provides a simple to use yet powerful data-gathering API. GCspy scales to allow very large heaps to be visualised effectively and efficiently. It allows already-running, local or remote, systems to be visualised and those systems to run at full speed outside the points at which data is gathered. Its visualisation tool presents this information in a number of novel ways.
Tim Harris described his work on Managing elastic structures. Applications that are elastic in their memory requirements require feedback over the amount of memory required by the data structures that they are manipulating. We are investigating whether it is reasonable for this to be provided as an adjunct to garbage collection rather than being re-computed (perhaps erroneously) by the application
The workshop spent some time discussing future directions. A number of topics were felt to be important and worth pursuing within the memory management community. Many of these focussed on understanding the performance of memory management subsystems. How can we characterise the behaviour of application programs? How can we understand when things are going wrong and why? Can we identify realistic benchmarks? The workshop also recognised that memory management included more than GC and that we should attempt to draw in people from the hardware and operating systems communities.
It was important to be able to acquire a high-level understanding of why things go wrong. Comparisons between the application-level and the GC-level were necessary. A number of tools are available. GCspy focusses on the needs of the memory manager implementer by providing a visualisation of the memory management system (heap spaces, free-lists, and so on) whereas commercial tools like JInsight, JProbe allow application developers to drill down to understand how the heap was populated, the cause of space leaks, and so forth.
There is a lack adequate and shared benchmarks and other stress testing workloads. Although researchers have used many applications for measurements, many are too small to allow conclusions to be drawn with confidence, or come from a limited range of classes of program (compiler development tools are an unsurprisingly common pool from which benchmarks are drawn). The SPECjvm98 benchmarks are widely used but few programs from this suite are suitable for GC development. SPECjbb2000 (and pBOB) were felt to be an improvement. Although it is often difficult to obtain large-scale, commercial applications for measurement, benchmarking and performance measurement is an area in which collaboration would benefit the entire community and in which mm-net might play a part.
It was agreed that this was a matter that a future workshop might focus upon.
Finally, it was agreed that mm-net should set itself concrete goals that could leverage the different talents present in the Network.
The UK Memory Management Network is an EPSRC funded network of memory management researchers in the UK.
Mm-net is grateful to the Department of Computer Science at the University of Glasgow for hosting this workshop. In particular, we thank Susanne Mackenzie for her smooth local organisation.
Richard Jones
July 2002
Problems with this page?
Contact the mm-net webmaster
Last modified Tue Nov 30 10:50:07 GMT 2004