Hans J. Boehm

Work Phone Number: (650) 857-3406 HP Labs Central Phone Number: (650) 857-1501 Email addresses: Hans.Boehm@hp.com boehm@acm.org Physical address: 1501 Page Mill Rd., MS 1183, Palo Alto, CA, 94304

Prior to that I worked/studied at

1996-1999

SGI

1989-1996

Xerox PARC

1984-1989

Rice University (Assistant and Associate Professor)

1982-1984

University of Washington (Assistant Professor)

1978-1983

Cornell University (graduate student)

1974-1978

University of Washington (undergraduate student)

Things I've worked on recently:

• Helping to uncover and remove obstacles to writing reliable multithreaded code. Unfortunately, programming language definitions, and sometimes even computer architecture specifications have been so vague that they can't possibly serve as a basis for teaching programmers, or as reasonable guidelines for compiler writers. I participated in the revision of the Java "memory model", and we are now looking hard at C and C++. The immediate target is real thread support in the next C++ standard, with a clear definition of which assignments may be seen by which read accesses, and full support of hardware-provided atomic operations.
• Continued work on our garbage collector, sometimes in support of the above. Recently I've worked on scalable parallel collection (now integrated into the collector and GCJ), and tools for understanding allocation behavior.
• Exploring mostly Java-related performance issues on Linux/Itanium. To look at Java issues, I've been working primarily in the context of GCJ, the GNU static Java compiler, to which I've been contributing code on occasion. Slides for a recent presentation are here.
• The beginnings of a profiling toolkit for Linux, and some of the underpinnings to make that possible. The underpinnings include better support for lock-free data structures, to make it possible to run interesting code in signal handlers.

Conservative Garbage Collection

This work was started at Rice University, where it grew out of work on the implementation of the Russell programming language, which was jointly developed with Alan Demers. It was developed substantially further at Xerox PARC, SGI, and HP, with the help of many other contributors. It resulted in a generally available and widely used garbage collector library, as well as a number of publications.

Multiprocessor Synchronization Algorithms

I have worked on fast lock implementations for Java virtual machines, and I'm generally interested in fast multiprocessor synchronization. I coauthored a paper on practical implementation of monitor locks without hardware support. A package to support (somewhat) portable use of atomic memory operations was developed and is distributed as part of the qprof project.

Constructive Real Arithmetic

Together with Corky Cartwright, Vernon Lee, and others, I explored practical implementations of "exact" real computer arithmetic. Numbers are represented exactly internal to the computer, in a form that allows evaluation to any requested precision for display. This resulted in a several papers, as well as a Calculator implementation that is still in occasional use. More recently, I reimplemented both the calculator and library in Java, with some new twists.

Ropes or Scalable Strings

The Xerox Cedar environment relies heavily on a scalable implementation of strings, i.e. sequences of characters represented as trees. (The Cedar implementation was developed by Russ Atkinson, Michael Plass, and others. Similar ideas were also developed elsewhere.) This idea simplifies many interesting software systems, but hasn't propagated very far. I reimplemented it both in C at Xerox (the cord package, now a part of the garbage collector distribution) and in a very different form for C++ at SGI (the "rope" package in the SGI STL).

The Russell Programming Language

At Cornell, the University of Washington, and at Rice, I worked on the semantics and implementation of a polymorphically-typed programming language called Russell. A rather dated implementation can still be found here. The language was mostly designed by Donahue and Demers at Cornell. Unfortunately, some of the good ideas from this and related designs (e.g."templates" with real separate type checking and compilation) still haven't completely made it into mainstream programming languages. (Fortunately, neither did the bad ideas.)

• Threads in C++0x: An Update (Apr 9, 2008, ACCU Silicon Valley Talk)
• Getting C++ Threads Right (Given at William and Mary, University of Virginia, and Google) (Youtube video of Google talk)
• Reordering Constraints for Pthread-Style Locks (PPoPP 07 slides)
• Towards a C++ Memory Model (Slightly edited slides from Intel talk, which evolved from talks at Microsoft and then Northeastern)
• A talk by the same title as above, presented at the November ACCU Silicon Valley meeting. This version is aimed more at developers, and less at compiler writers and researchers.
• Finalization Should Not Be Based on Reachability (ISMM 06 Wild & Crazy Ideas session)
• Finalizers, Threads, and the Java Memory Model
• Threads Cannot be Implemented as a Library (PLDI 2005)
• An Almost Non-Blocking Stack (PODC 2004)
• BDWGC tutorial (ISMM 2004)
• The Space Cost of Lazy Reference Counting (POPL 2004)
• Performance of Non-Moving Garbage Collectors
• Destructors, Finalizers, and Synchronization (POPL 2003)