Work Phone Number: (650) 857-3406
HP Labs Central Phone Number: (650) 857-1501
1501 Page Mill Rd., MS 1183, Palo Alto, CA, 94304
I have been at HP Labs
since September, 1999. I am now a Principal Research Scientist
in the Systems Research Lab.
Prior to that I worked/studied at
- Xerox PARC
- Rice University (Assistant and Associate Professor)
- University of Washington (Assistant Professor)
- Cornell University (graduate student)
- University of Washington (undergraduate student)
Things I've worked on recently:
ACM SIGPLAN from 2001 to 2003.
I am an ACM Fellow.
- Understanding how to program systems with non-volatile
byte addressable memory. We expect that such memory will become
far more common, and it is not yet clear if and how it will impact our
basic programming model.
- 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 more recently led a successful effort
to properly define shared variable semantics in C and C++.
This was part of a larger effort to add thread support to those
languages. I continue to chair the C++ concurrency standardization
study group (WG21/SG1).
- Understanding the compiler optimization consequences of the
preceding work. Some time-honored optimization techniques
(e.g. certain flavors of register promotion and vectorization) are now
clearly wrong in light of the preceding work, and were arguably
wrong all along. Other techniques that previously suffered from uncertain
legitimacy are now clearly correct.
Alternative approaches to shared memory programming that simplify
(or perhaps make possible) the programmer's job. I participate in
the C++ transactional memory standardization effort (WG21/SG5).
I have worked on "always on" data-race detection.
Interest areas and Past Projects
- 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.
I still maintain the mailing list, etc., but I am only occasionally
involved in maintaining the code base.
- 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.
- Java implementation and GCJ
I implemented the hash-table-based synchronization mechanism, and a few
other pieces for
GCJ, the GNU static
Java compiler. I also helped build some of the underlying threads
infrastructure on Itanium Linux.
Slides for an ancient presentation are
- Qprof and atomic_ops
- I built a simple
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.
- 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
- 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
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.)
Slides from some recent talks
Nondeterminism is Unavoidable,
But Data Races are Pure Evil,
RACES'12 Workshop, October 21, 2012.
Can Seqlocks Get Along with Programming Language Memory Models?,
Beijing, China, June 16, 2012.
Threads and Shared Variables in C++11 and elsewhere,
ACM San Francisco Bay Area
Professional Chapter, April 18, 2012.
Threads and Shared Variables in C++11
, GoingNative 2012.
How to Miscompile Programs with "Benign" Data Races, HotPar 2011.
Performance Implications of Fence-Based Memory Models, MSPC 2011.
Threads and Shared Variables in C++0x, BoostCon 2011.
Programming Language Memory Models: What do Shared Variables Mean? (2010, variants given at UC Berkeley (Oct.), UCSB (Sept.), CMU (March), a
revised version given at ECOOP 2011)
Semantics of Shared Variables and Synchronization a.k.a. Memory Models
(3.5 hour tutorial presented with Sarita Adve at PLDI, June 2010)
Transactional Memory Should be an Implementation Technique, Not a Programming Interface (Presented at HotPar09 workshop)
Reordering Constraints for Pthread-Style Locks (PPoPP 07 slides)
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)
A list of my selected paper publications is here.
The relicensed version of Joel Bartlett's 1993 Scheme2c system is
here. This is published here for reference.
You probably want a more modern update
Please be careful unpacking the original version. As with
much software of the time, it unpacks directly into the current
Boehm family personal home page
(external to HP).