[Beowulf] Everything You Know (about Parallel Programming) Is Wrong!: A Wild Screed about the Future

Eugen Leitl eugen at leitl.org
Tue Mar 27 08:15:51 PDT 2012


Mon 2:00-3:00 pm - Pavilion East

Everything You Know (about Parallel Programming) Is Wrong!: A Wild Screed
about the Future

invited speakerDavid Ungar, IBM Research, USA

In the 1970’s, researchers at Xerox PARC gave themselves a glimpse of the
future by building computers that, although wildly impractical at the time,
let them experience plentiful fast cycles and big memories. PARC researchers
invented Smalltalk, and the freedom afforded by such a dynamic, yet safe,
language, led them to create a new experience of computing, which has become
quite mainstream today.

In the end of the first decade of the new century, chips such as Tilera’s can
give us a glimpse of a future in which manycore microprocessors will become
commonplace: every (non-hand-held) computer’s CPU chip will contain 1,000
fairly homogeneous cores. Such a system will not be programmed like the
cloud, or even a cluster because communication will be much faster relative
to computation. Nor will it be programmed like today’s multicore processors
because the illusion of instant memory coherency will have been dispelled by
both the physical limitations imposed by the 1,000-way fan-in to the memory
system, and the comparatively long physical lengths of the inter- vs.
intra-core connections. In the 1980’s we changed our model of computation
from static to dynamic, and when this future arrives we will have to change
our model of computation yet again.

If we cannot skirt Amdahl’s Law, the last 900 cores will do us no good
whatsoever. What does this mean? We cannot afford even tiny amounts of
serialization. Locks?! Even lock-free algorithms will not be parallel enough.
They rely on instructions that require communication and synchronization
between cores’ caches. Just as we learned to embrace languages without static
type checking, and with the ability to shoot ourselves in the foot, we will
need to embrace a style of programming without any synchronization

In our Renaissance project at IBM, Brussels, and Portland State,
(http://soft.vub.ac.be/~smarr/renaissance/) we are investigating what we call
“anti-lock,” “race-and-repair,” or “end-to-end nondeterministic” computing.
As part of this effort, we have build a Smalltalk system that runs on the
64-core Tilera chip, and have experimented with dynamic languages atop this
system. When we give up synchronization, we of necessity give up determinism.
There seems to be a fundamental tradeoff between determinism and performance,
just as there once seemed to be a tradeoff between static checking and

The obstacle we shall have to overcome, if we are to successfully program
manycore systems, is our cherished assumption that we write programs that
always get the exactly right answers. This assumption is deeply embedded in
how we think about programming. The folks who build web search engines
already understand, but for the rest of us, to quote Firesign Theatre:
Everything You Know Is Wrong!

David Ungar is an out-of-the-box thinker who enjoys the challenge of building
computer software systems that work like magic and fit a user's mind like a
glove. He received the 2009 Dahl-Nygaard award for outstanding career
contributions in the field of object-orientation, and was honored as an ACM
Fellow in 2010. Three of his papers have been honored by the Association for
Computing Machinery for lasting impact over ten to twenty-four years: for the
design of the prototype-based Self language, dynamic optimization techniques,
and the application of cartoon animation ideas to user interfaces. He enjoys
a position at IBM Research, where he is taking on a new challenge:
investigating how application programmers can exploit manycore systems, and
testing those ideas to see if they can help scale up analytics.

[NOTE] this session is organized as a joint event with the AGERE! workshop

More information about the Beowulf mailing list