A Theory of Speculative Computation

Boudol, Gérard; Petri, Gustavo

doi:10.1007/978-3-642-11957-6_10

Cited by 14 publications

(7 citation statements)

References 31 publications

Supporting

Mentioning

Contrasting

Order By: Relevance

“…-The construction is independent from the language syntax and thread-local operational semantics, which is highly desirable for tackling a complex language like C. This contrasts with explicit-speculation calculi, e.g. [15,22]. -For entirely thread-local computation, as thread-local variables do not create memory events, optimisations are already factored into the computation of the thread-local LTS.…”

Section: R X=0 {A}mentioning

confidence: 99%

The Problem of Programming Language Concurrency Semantics

Batty

Memarian

Nienhuis

et al. 2015

Programming Languages and Systems

View full text Add to dashboard Cite

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.

show abstract

Section: R X=0 {A}mentioning

confidence: 99%

The Problem of Programming Language Concurrency Semantics

Batty

Memarian

Nienhuis

et al. 2015

Programming Languages and Systems

View full text Add to dashboard Cite

show abstract

“…By this we mean that it consists in a set of rules that specify what can be the next step to perform, to go from one configuration to another. This contrasts with [8] for instance, where a whole sequence of steps is only deemed a valid behavior if it can be shown equivalent to a computation in normal order. We notice that, again constrasting [8], our model preserves a notion of causality: a read can only return a value that is present in the shared memory, or that is previously written by some thread.…”

Section: Introductionmentioning

confidence: 95%

“…This contrasts with [8] for instance, where a whole sequence of steps is only deemed a valid behavior if it can be shown equivalent to a computation in normal order. We notice that, again constrasting [8], our model preserves a notion of causality: a read can only return a value that is present in the shared memory, or that is previously written by some thread. Our notion of a temporary store is quite similar to the "reorder box" of [13], but formulated in the standard framework of programming language semantics.…”

Section: Introductionmentioning

confidence: 95%

Relaxed Operational Semantics of Concurrent Programming Languages

Boudol

Petri

Serpette

2012

Electron. Proc. Theor. Comput. Sci.

Self Cite

View full text Add to dashboard Cite

We propose a novel, operational framework to formally describe the semantics of concurrent programs running within the context of a relaxed memory model. Our framework features a "temporary store" where the memory operations issued by the threads are recorded, in program order. A memory model then specifies the conditions under which a pending operation from this sequence is allowed to be globally performed, possibly out of order. The memory model also involves a "write grain," accounting for architectures where a thread may read a write that is not yet globally visible. Our formal model is supported by a software simulator, allowing us to run litmus tests in our semantics

show abstract

“…From a certified compiler perspective, an operational definition of the JMM is desirable. There are several attempts to provide such a semantics [7,8,10,16] but none of them has been used in a proof assistant. Our operational semantics is inspired by the TSO memory model proposed in [35] which has been formalized in Coq.…”

Section: Related Workmentioning

confidence: 99%

Plan B

Demange

Laporte

Zhao

et al. 2013

Proceedings of the 40th Annual ACM SIGPLAN-SIGACT Symposium on Principles of Programming Languages

View full text Add to dashboard Cite

Recent advances in verification have made it possible to envision trusted implementations of real-world languages. Java with its type-safety and fully specified semantics would appear to be an ideal candidate; yet, the complexity of the translation steps used in production virtual machines have made it a challenging target for verifying compiler technology. One of Java's key innovations, its memory model, poses significant obstacles to such an endeavor. The Java Memory Model is an ambitious attempt at specifying the behavior of multithreaded programs in a portable, hardware agnostic, way. While experts have an intuitive grasp of the properties that the model should enjoy, the specification is complex and not well-suited for integration within a verifying compiler infrastructure. Moreover, the specification is given in an axiomatic style that is distant from the intuitive reordering-based reasonings traditionally used to justify or rule out behaviors, and ill suited to the kind of operational reasoning one would expect to employ in a compiler. This paper takes a step back, and introduces a Buffered Memory Model (BMM) for Java. We choose a pragmatic point in the design space sacrificing generality in favor of a model that is fully characterized in terms of the reorderings it allows, amenable to formal reasoning, and which can be efficiently applied to a specific hardware family, namely x86 multiprocessors. Although the BMM restricts the reorderings compilers are allowed to perform, it serves as the key enabling device to achieving a verification pathway from bytecode to machine instructions. Despite its restrictions, we show that it is backwards compatible with the Java Memory Model and that it does not cripple performance on TSO architectures.

show abstract

A Theory of Speculative Computation

Cited by 14 publications

References 31 publications

The Problem of Programming Language Concurrency Semantics

The Problem of Programming Language Concurrency Semantics

Relaxed Operational Semantics of Concurrent Programming Languages

Plan B

Contact Info

Product

Resources

About