Tim Harris, Microsoft Research Transactional memory and garbage collection
We've recently been studying the use of software transactional memory (STM) for controlling concurrent access to data structures. In this talk I'll describe how our implementation of STM benefits from close integration with the garbage collector in a managed runtime system: unlike earlier implementations we allow transactions to execute across GC cycles and, within a transaction, we allow the GC to reclaim objects that are dead whether or not the transaction commits.

Hongseok Yang, QMUL Beyond Reachability: Shape Abstraction in the Presence of Pointer Arithmetic
Previous shape analysis algorithms use a memory model where the heap is composed of discrete nodes that can be accessed only via access paths built from variables and field names, an assumption that is violated by pointer arithmetic. In this talk I will show how this assumption can be removed, and pointer arithmetic embraced, by using an analysis based on separation logic.
I will describe an abstract domain whose elements are certain separation logic formulae, and an abstraction mechanism that automatically transits between a low-level RAM view of memory and a higher, fictional, view that abstracts from the representation of nodes and multiword linked-lists as certain configurations of the RAM. I will also report experimental results obtained from running the analysis on a number of classic algorithms for dynamic memory management.

Jeremy Singer, U. Manchester Garbage Collection, Program Comprehension and Machine Learning: a recipe for sucess!
Take the best techniques from two diverse areas of computer science research - (1) program comprehension and (2) machine learning. Mix together and apply to memory management. Program comprehension allows us to study why garbage collection happens. Machine learning allows us to control how garbage collection happens. Preliminary results have been carefully cooked up in the Jikes RVM system, and taste delicious!

Richard Hayden, Imperial Visualising Dynamic Memory Allocators

Simon Marlow, Microsoft Research A block-structured heap simplifies parallel GC

Ian Rogers, U. Manchester The Jikes RVM and Java Operating Systems
This talk will focus on recent efforts in combining the Jikes RVM and the JNode OS. JNode is an open source Java operating system. The Jikes RVM is a research virtual machine with an adaptive optimizing compilation framework. In combining these two projects we've taken a number of different approaches. We'll present some early results from this work. We'll also present some of our motivation and other recent Jikes RVM related work carried out at Manchester.

Elisa Gonzalez Boix, VUB Semi-Automatic Garbage Collection for Mobile Networks
pdf

Chris Ryder, U. Kent LACE: Lifetime-Aware Collection

Sebastien Marion, U. Kent Micro-patterns for GC

Sofiane Naci, U. Cambridge Improving Inter-Nest Data Locality Using Loop Transformations
Most current data locality optimisation techniques are targeted to enhancing intra-nest locality, focusing on individual loop nests at a time. However, in data-extensive applications arrays are typically accessed in more than one loop nest and there exists major data reuse between loops accessing the same data. McKinley and Temam (ACM Transactions on Computer Systems 17, 1999) showed that while almost 94% of data reuse and cache hits occur is single loop nests, 80% of cache misses are inter-nest.
In this talk, we present a compiler strategy that improves inter-loop data locality using code restructuring and loop transformations. Our approach captures data reuse between all loop nests in the program and then splits and reorders the nests so that those sharing arrays are closer together. The transformed program is then further optimized using loop transformations. We use whole program analysis and Integer Linear Programming to find the best nest ordering.

Mark Adcock, U. Cambridge Cache Optimisation of Dynamic Recursive Data Structures
The performance of a large dynamic Recursive Data Structure (RDS) can often decrease as a program executes due to degrading data layout. We consider semi-automatic solutions to the problem, which, in terms of performance and ease of application, lie between automatic solutions such as locality-improving GCs (eg Chen et al [1]) and manual solutions such as using an RDS designed for good cache behaviour (eg `Cache-Oblivious Search Trees', Brodal et al [2]).
We consider the specific example of repeated lookups, deletions and insertions in a binary search tree, and construct an optimisation to maintain small clusters of connected nodes in each cache line. Code is inserted into the read-only lookup loop to detect and correct poor data layout. Memory usage is controlled by compacting partially-full cache lines, and program interruption is reduced by performing node movement work in proportion to normal program work. The optimisation reduces execution times by 25%, using only 5% extra memory.
[1] W. Chen, S. Bhansali, T. Chilimbi, X. Gao, and W. Chuang. Profile-guided proactive garbage collection for locality optimisation. In Proceedings of the 2006 ACM-SIGPLAN conference on Programming Language Design and Implementation
[2] G. Brodal, R. Fagerberg, and R. Jacob. Cache oblivious search trees via binary trees of small height. In Proceedings of the 2002 ACM-SIAM Symposium on Discrete Algorithms

Problems with this page?
Contact the mm-net webmaster
Last modified Thu Nov 2 13:35:49 GMT 2006