Correctly translating concurrency primitives

Abstract

Motivated by the question of correctness of a specific implementation of concurrent buffers in the lambda calculus with futures underlying Alice ML, we prove that concurrent buffers and handled futures can correctly encode each other. Our translations map waiting on handled futures to queuing of concurrent buffers and vice versa. Correctness of translations means that they preserve and reflect the observations of may-and must-convergence. As a consequence of compositionality, they are also adequate with respect to a contextually defined notion of observational program semantics. We demonstrate that our approach to the correctness of implementations applies uniformly to the whole compilation process from high-level to low-level concurrent languages.

A contextual semantics for concurrent Haskell with futures

“…Our calculus CHF is also related to the (call-byvalue) lambda-calculus with futures λ(fut) ([NSS06]) which models the core language of Alice ML [Ali11] and has concurrent futures similar to ours, in [NSSSS07] a program equivalence based on contextual equivalence with mayand should-convergence is defined for λ(fut) and a set of program transformations is shown correct. In [SSSSN09] variants of λ(fut) are presented and their equivalence is shown. In difference to CHF, the calculus λ(fut) is a model of an impure programming language, and thus there is no distinction between functional and imperative computations.…”

Observational program calculi and the correctness of translations

“…synchronizing memory cells (that are either filled or empty). In [SSSSN09] this question is investigated. Starting from an implementation of concurrent buffers using handled futures and memory cells, and an implementation of handled futures using buffers, three languages L b , L h , and L bh (where L bh is the language containing both primitives) are defined, and then translations (in the sense of Definition 3.5) between them were analyzed by describing the embeddings and the encodings of one primitive by the other one.…”

“…Typical examples are the removal of syntactic sugar, but also for reasoning about the implementations of language extensions in terms of a core language (which are often packaged into the language's library). Typical examples are implementations of channels, buffers, or semaphores using a synchronizing primitive in the core part of the language, for example using mutable reference cells and futures in Alice ML [Ali07,NSS06,SSSSN09], or using MVars in Concurrent Haskell [PGF96]. Correctness of these implementations can be proved by interpreting the implementation as a translation from the extended language into the original language and then showing correctness of the translation.…”

Minimal Translations from Synchronous Communication to Synchronizing Locks

“…For instance, λ (fut) [7] is a program calculus that models the core of the strict concurrent functional language Alice ML, and it has concurrent threads, handled futures, and memory cells with an atomic exchange-operation. Also other shared memory synchronization primitives like concurrent buffers and their encodability into λ (fut) are analyzed [24]. Other examples are the calculi CH [19] and CHF [14,15,21].…”