|
Hans-J. Boehm
Email address:
boehm@acm.org
Physical location:
Palo Alto, CA
|
General
I am a software engineer at Google, where I've been since March 2014.
I now work mostly on concurrent programming issues, both generally, and
focussed on Android.
Publications
A list of my selected publications is here.
Or see my Google Scholar page
here. Or
my ACM author page.
Where I've been
In the past I've worked or studied at:
- 2014-
- Google
- 1999-2014
- HP Labs (Researcher, Research Manager)
- 1996-1999
- SGI (Software Engineer)
- 1989-1996
- Xerox PARC (Researcher)
- 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)
- 1971-1974
- Roosevelt High School, Seattle, WA (student)
Past Projects
Recent projects:
- I contribute to Android's ART Java language runtime.
I work mostly on addressing concurrent programming, and sometimes
garbage collection issues, in the runtime.
- I use experience from the above to uncover and remove obstacles to writing
reliable multithreaded code.
Unfortunately, until the early 2000s, most programming language definitions,
and sometimes even computer architecture specifications, dealt with
concurrency vaguely, or not at all.
They often couldn't efectively 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 subsequently led a successful effort
to properly define shared variable semantics in C and C++.
Until 2017, I chaired the ISO C++ Concurrency Study Group (WG21/SG1),
which officially added thread support to C++ and more properly defined it.
I continue to actively participate in resolving remaining issues.
- I implemented the arithmetic evaluation engine for Google's
Android Calculator. It avoids cumulative errors, and provides
arbitrarily scrollable, always accurate, results. The underlying libraries
are
open source.
Some Older 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.
It is currently maintained primarily by Ivan Maidanski.
- 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.
I developed
libatomic_ops
, which was useful at the time,
and helped us to avoid some
of its mistakes in the later design of C++11 atomics.
- 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 several papers and a sequence of implementations,
including a Java one. It served
as the basis of the more recent work on arithmetic in Google's
Android calculator.
- 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.
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).
Major Awards
Slides from some recent talks
-
Using weakly ordered C++ atomics correctly, Sept. 21, 2016.
Talk.
-
Myths and Misconceptions about Threads, SPAA 2015 keynote talk, June 13, 2015.
-
Transactional Memory in C++, TRANSACT 2015 invited talk, June 16, 2015.
-
The C11 and C++11/14 Memory Model,
Lockheed, Mar. 3, 2015. (More of a tutorial than other recent talks.)
-
Putting Threads on a Solid Foundation: Some Remaining Issues,
January 2015.
-
Outlawing Ghosts: Avoiding Out-Of-Thin-Air Results,
MSPC 2014.
-
Nondeterminism is Unavoidable,
But Data Races are Pure Evil,
RACES'12 Workshop, October 21, 2012.
-
Can Seqlocks Get Along with Programming Language Memory Models?,
MSPC 2012,
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
slightly longer,
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)
Miscellaneous
Boehm family personal home page.