The Problem of Programming Language Concurrency Semantics

Abstract

Abstract. Despite decades of research, we do not have a satisfactory concurrency semantics for any general-purpose programming language that aims to support concurrent systems code. The Java Memory Model has been shown to be unsound with respect to standard compiler optimisations, while the C/C++11 model is too weak, admitting undesirable thin-air executions.Our goal in this paper is to articulate this major open problem as clearly as is currently possible, showing how it arises from the combination of multiprocessor relaxed-memory behaviour and the desire to accommodate current compiler optimisations. We make several novel contributions that each shed some light on the problem, constraining the possible solutions and identifying new difficulties.First we give a positive result, proving in HOL4 that the existing axiomatic model for C/C++11 guarantees sequentially consistent semantics for simple race-free programs that do not use low-level atomics (DRF-SC, one of the core design goals). We then describe the thin-air problem and show that it cannot be solved, without restricting current compiler optimisations, using any per-candidate-execution condition in the style of the C/C++11 model. Thin-air executions were thought to be confined to programs using relaxed atomics, but we further show that they recur when one attempts to integrate the concurrency model with more of C, mixing atomic and nonatomic accesses, and that also breaks the DRF-SC result. We then describe a semantics based on an explicit operational construction of out-of-order execution, giving the desired behaviour for thin-air examples but exposing further difficulties with accommodating existing compiler optimisations. Finally, we show that there are major difficulties integrating concurrency semantics with the C/C++ notion of undefined behaviour.We hope thereby to stimulate and enable research on this key issue.

Overhauling SC atomics in C11 and OpenCL

“…Happens-before (hb) is a transitive relation that includes sequenced-before and synchronisation edges, and puts initial events before all other events. 10 We use hbl to abbreviate happens-before to events on the same location. A write is visible (vis) to a read if it is the most recent write to that location in happens-before.…”

“…Correctness in any relaxed memory setting is notoriously evasive; indeed, the subtleties of relaxed memory have previously led to confirmed bugs in language specifications [7,10], deployed processors [1], compilers [27,40] and vendor-endorsed programming guides [3]. The importance of correctness in the context of C11 is well-known.…”

“…The C11 memory model has been formalised by several researchers, in varying degrees of completeness, and with varying degrees of fidelity to the standard [2,7,38]. These formalisation efforts have proved fruitful; they have, for instance, enabled the construction of simulators that automatically explore the allowed behaviours of small C11 programs (called litmus tests) [2,7,13,29], underpinned the design of program logics for specifying and verifying C11 programs [37,38], and they provide a firm foundation for ongoing debate about the design of the C11 memory model itself [10,39]. The OpenCL memory model (introduced in version 2.0 of the standard) has received comparatively little academic attention, with the notable exception of the work of Gaster et al [17], which we discuss further in §7.…”

UTP Semantics for Shared-State, Concurrent, Context-Sensitive Process Models

“…These labels are analogous to the notion of an abstract program counter that is found in many approaches to reasoning about concurrent programs [16], so that it is possible to talk about the particular program statement that any particular thread is trying to execute. They allow the semantics to track the progress of each thread while also allowing the non-deterministic interleaving of atomic actions.…”

The virtues of conflict

“…However, we currently cannot handle POWER and ARM without additional formalisms. Recent work [14] studies the difficulty of devising an axiomatic memory model that is consistent with the standard compiler optimizations for C11/C++11. Such fine-grained handling of desirable/undesirable thin-air executions is outside of the scope of our work.…”