Paper presented by Martin Vechev at the Nineteenth European Conference on Object-Oriented Programming, (Glasgow, Scotland, July 2005).

Presents a new abstract, generalized, and more accurate algorithm for concurrent garbage collection, shows how both pre-existing and new concrete algorithms can be derived, and studies the relative performance of four algorithms.

Paper presented at the Conference on Languages, Compilers, and Tools for Embedded Systems (Chicago, Illinois, June 2005).

Shows how two new techniques, syncopation and arraylet pre-tenuring can be combined with an over-clocked scheduler to extend the benefits of generational systems to real-time garbage collection.

Keynote presentation at the Sixth Ptolemy Conference at U.C. Berkeley (May 2005). Also presented at the Universität Salzburg (June 2005).

Overview of Java technology for real-time systems, focusing on the innovations of the Metronome project at IBM Research.

Paper presented by Harel Paz Fourteenth International Conference on Compiler Construction, (Edinburgh, Scotland, April 2005).

A number of improvements to the Recycler algorithm greatly reduce the load on the cycle collector and yield a corresponding increase in performance.

Paper presented at the ACM Conference on Object-Oriented Programming Languages, Systems, and Applications, Vancouver, British Columbia, October 2004.

Tracing and reference counting are shown to be duals of one another, and all garbage collectors to be various types of hybrids of tracing and reference counting.

Paper presentated at at the Workshop on Languages and Runtimes (Vancouver, British Columbia, October 2004).

A vision for future virtual machines, in which all components, from the run-time system down to the hardware instruction set, are virtualized and dynamically generated.

Presentation describing the Kava approach to value types and how it could be integrated into a future version of the Java language.

Paper presentated by Martin Vechev at the International Symposium on Memory Management (Vancouver, British Columbia, October 2004).

An analysis of the conditions under which redundant write barriers for concurrent garbage collectors could be eliminated, and a trace-based evaluation showing that over 90% of barriers are often redundant.

Paper presentated by Sunil Soman at the International Symposium on Memory Management (Vancouver, British Columbia, October 2004).

Design and implementation of a system that allows dynamic switching between garbage collection algorithms, and a study of the potential for improvement.

Paper presentated at the First Watson Conference on Interaction between Architecture, Circuits, and Compilers (Yorktown Heights, New York, October 2004).

Hardware instructions that allow explicit handling of cache misses and a programming model that uses the hardware support to provide an alternative approach to multi-threading.

Paper presentated at the Fourth ACM International Conference on Embedded Software (Pisa, Italy, September 2004).

Design, implementation, and evaluation of several variants of two garbage collectors for embedded systems. A combination of object compression and a sliding compacting algorithm yields compact code and high performance in very small heaps.

Extended presentation of a paper appearing in the ACM Conference on Object-Oriented Programming Languages, Systems, and Applications, Vancouver, British Columbia, October 2004.

Tracing and reference counting are shown to be duals of one another, and all garbage collectors to be various types of hybrids of tracing and reference counting.

Paper presented by Perry Cheng at the Workshop on Java Technologies for Real-Time and Embedded Systems, Catania, Sicily, November 2003.

True real-time garbage collection, as we have implemented in the Metronome, can greatly simplify the programmer interface for real-time systems over that provided by environments such as the Real-Time Specification for Java (RTSJ).

Paper presented by David Grove at the ACM Conference on Object-Oriented Programming Languages, Systems, and Applications, Anaheim, California, October 2003.

Describes a module system for Java that is compatible with the existing Java language but provides significantly improved support for building large, robust, long-lived systems out of modular components. We implemented MJ and converted the Tomcat web application server from using classloaders to using about 30 MJ modules. The resulting system is much easier to install and maintain, and also achieves a 30% speedup.

Paper presented at the ACM Conference on Languages, Compilers, and Tools for Embedded Systems, San Diego, California, June 2003.

Describes the Metronome real-time garbage collector's mechanisms for limiting fragmentation and the resulting wasted space. The application is characterized in terms of a fragmentation factor λ. For real-world applications λ is very small and the collector only needs to copy a very small number of objects to limit fragmentation.

Extended presentation of the results published in POPL 2003; presented at U.C. Berkeley Programming Systems/Real-time Systems Seminar (March 2003), U.C. Santa Barbara Computer Science Colloquium (March 2003), Microsoft Research Seminar (March 2003), Washington University Computer Science Colloquium (October 2003), Universität Salzburg (June 2004).

Describes a real-time garbage collector for uniprocessors, implemented for Java in the Jikes RVM virtual machine. The collector makes use of low-overhead read barriers (4%), and is mostly non-copying. Pause times are low and utilization meets the target within a small range of variation.

Paper presented by Perry Cheng at the Thirtieth ACM Symposium on Principles of Programming Languages (POPL), New Orleans, Louisiana, January 2003.

Describes a real-time garbage collector for uniprocessors, implemented for Java in the Jikes RVM virtual machine. The collector makes use of low-overhead read barriers (4%), and is mostly non-copying. Pause times are low and utilization meets the target within a small range of variation.

Paper presented at the European Conference on Object-Oriented Programming (ECOOP), Málaga, Spain, June, 2002.

Shows how the Java object model can be implemented with only one header word. The result is a 14% space savings and 0.6-4% speedup.

Paper presented at the ACM Conference on Programming Language Design and Implementation, Snowbird, Utah, June 20, 2001.

This presentation includes extensive animations showing how the multiprocessor, concurrent, reference counting, cycle collecting garbage collector works.

Paper presented at the Joint ACM Java Grande/ISCOPE Conference, Stanford, California, June 4, 2001.

Kava extends allows the abstractions of object-oriented programming to be applied down to the level of individual bits. This in turn allows the distinction between primitive types (like int) and classes to be eliminated, and for the primitive types to be defined in the language. It also allows rich programmer-defined value types to be added to the language.
An earlier version of this work was presented at the Dagstuhl workshop 451.

Paper presented at the Department of Computer Science, University of Washington, June 5, 2001.

This work quantitatively evaluates the tradeoffs involved between various garbage collection techniques when applied to parallel multiprocessor garbage collection.

Paper presented at the Programming Languages Seminar, U.C. Berkeley, February 6, 2001.

This presentation includes extensive animations showing how the multiprocessor, concurrent, reference counting, cycle collecting garbage collector works.

Presented at Dagstuhl Seminar 451 on Effective Implementation of Object-Oriented Programming Languages, Schloss Dagstuhl, Germany, November 2000.

Bit-Level Object-Oriented Programming allows the abstractions of object-oriented programming to be applied down to the level of individual bits. This in turn allows the distinction between primitive types (like int) and classes to be eliminated, and for the primitive types to be defined in the language. It also allows rich programmer-defined value types to be added to the language.

A troika of ideas for improving memory management in Java: a decoupled object model that uses as little as one word of overhead per object; a sandboxing technique that allows user- specified regions of memory to be freed without using any garbage collection; and a scalable, concurrent, incremental, garbage collector.

Paper presented at the ACM Conference on Programming Language Design and Implementation, Montreal, Canada, June 1998.

High performance synchronization for Java, now incorporated into most of IBM's Java virtual machines. When implemented in the JDK, mean application speedup was 1.22, maximum speedup was 1.7. Multiprocessor scalability also improved drammatically.

An analysis algorithm for languages like C++ and Java, and a collection of optimizations driven by the analysis. This algorithm is now being used in the JAX Java code compression tool (available on alphaWorks) and in an optimizer for a future IBM C++ compiler.

Design presented to JavaSoft, Netscape, and IBM, September-October 1997.

An earlier version of Thin Locks for Java, with a fully integrated mechanism for heavy-weight locks.

Two performance anomalies, and how hardware performance monitoring was used to track them down.

Paper presented at the ACM Conference on Object-Oriented Programming Systems, Languages, and Applications (OOPSLA), San Jose, California, October 1996.

Describes and evaluates Rapid Type Analysis, an algorithm that resolves 71% of the dynamic virtual function calls in a suite of seven C++ benchmark programs of significant size. Rapid Type Analysis also reduces compiled program size by 25%, and can be used to help the programmer understand his or her C++ program more easily.

Automatic transformations on pointer-intsenive programs: multi-tail recursion elimination, pointer expansion, malloc strip-mining, and others.

Thesis proposal defended at the University of California, Berkeley, Computer Science Division, March 1994.

Automatic transformations on pointer-intsenive programs: multi-tail recursion elimination, pointer expansion, malloc strip-mining, and others. A more in-depth talk than at NYU.

Guest lecture for Computer Science 267, Parallel Systems, at the University of California, Berkeley, Computer Science Division, March 1993. Includes material from my survey on compiler optimizations

Automatic transformations on pointer-intsenive programs: multi-tail recursion elimination, pointer expansion, malloc strip-mining, and others. A more in-depth talk than at NYU.

Presented at the University of California, Berkeley, Computer Science Division, 1992. Includes material from my M.S. thesis.

Three scientific applications and why compiler optimization failed to improve performance, and the manual optimizations that succeeded.

Paper presented at the Third ACM Symposium on Principles and Practices of Parallel Programming, July 1991.

A method for optimistically parallelizing any sequential computation in a distributed system when the result of the first part of the compuation can be guessed with reasonably high probability.

Paper presented at the ACM SIGPLAN/SIGOPS Workshop on Parallel and Distributed Debugging, Santa Cruz, California, December 1991.

Design and simulation results for a bus-monitoring device that logs memory transactions to allow deterministic replay of parallel programs on a shared-memory multiprocessor.

Paper presented at the Tenth IEEE Symposium on Reliable Distributed Systems, Pisa, Italy, September, 1991.

Demonstrates that deterministic replay can be achieved by only logging 1% of all file system operations, by using the volatile logging technique.