Non-deterministic Programming for Manycore Systems

Birds of a Feather

Non-deterministic Programming: A Solution for the Manycore Challenge?

Informal Workshop on the Opportunities of Embracing Non-determinism
in a Highly Parallel World

Goal

This BoF is meant to bring together people who are interested in
solving the challenges that the fine-grained parallelism of manycore and
exascale systems present.

Today, non-determinism is usually considered a problem researchers
have to solve when they are confronted with parallel programming.
However, non-deterministic programming and its potential has been the subject of
research for decades past.
With the increasing and unavoidable degree of parallelism, it may be the time to discuss it from
a new perspective. Thus, the main question of the workshop is, what if the
downsides of non-determinism are outweighed by its benefits?

We like to discuss the question of how a programming model for
non-deterministic parallel programming could be designed.
Thus, we want to think about what challenges need to be overcome and
what research questions need to be formulated.
Of interest are also which classic problems, for instance sorting, could be
solved in a non-deterministic manner, and what kind of computational problems
could benefit from speedups provided by additional parallelism even when trading
off precision for speed.

Attendance

This Birds of a Feather is supposed to propose and discus new ideas, without
any restriction of the creativity of its attendees. Every attendee is welcome to give a brief presentation,
show a demo, or just engage into a discussion with the audience.

Renaissance Project

This BoF will also be used as a venue to present the Renaissance Virtual Machine (RVM) of IBM Research.
On this occasion, the RVM will be opensourced and attendees will have the opportunity to
get introduced to the technical details of it. The RVM is meant to provide a common foundation for
research regarding non-deterministic parallel programming for manycore systems.
It is a Squeak/Pharo compatible Smalltalk VM supporting a classic shared-memory programming model.
Thus, the programmer has the illusion of a single object heap on which Smalltalk Processes can work in
parallel.

On top of the RVM, Ly was developed to embrace non-determinism and to harness emergence.

Confirmed Participants

David Ungar, Doug Kimelman, IBM Research
Brief introduction into the Renaissance project and demo of the current
status of their Ly/Sly language and manycore virtual machine.

Max OrHai, Andrew Black, Portland State University
Giving an overview of an example application to test the Renaissance ensemble code
as well as an outlook to a scalable non-deterministic parallel sorting algorithm.