The semantics of x86-CC multiprocessor machine code

@inproceedings{Sarkar2009TheSO,
  title={The semantics of x86-CC multiprocessor machine code},
  author={Susmit Sarkar and Peter Sewell and Francesco Zappa Nardelli and Scott Owens and Tom Ridge and Thomas Braibant and Magnus O. Myreen and Jade Alglave},
  booktitle={POPL '09},
  year={2009}
}
Multiprocessors are now dominant, but real multiprocessors do not provide the sequentially consistent memory that is assumed by most work on semantics and verification. Instead, they have subtle relaxed (or weak) memory models, usually described only in ambiguous prose, leading to widespread confusion. We develop a rigorous and accurate semantics for x86 multiprocessor programs, from instruction decoding to relaxed memory model, mechanised in HOL. We test the semantics against actual… Expand
A Better x86 Memory Model: x86-TSO
TLDR
A new x86-TSO model is presented that is sound with respect to real processors, reflects better the vendor's intentions, and is also better suited for programming. Expand
x86-TSO
TLDR
A new x86-TSO programmer's model is presented that is mathematically precise but can be presented as an intuitive abstract machine which should be widely accessible to working programmers and put x86 multiprocessor system building on a more solid foundation. Expand
86-TSO : A Rigorous and Usable Programmer ’ s Model for x 86 Multiprocessors
Exploiting the multiprocessors that have recently become ubiquitous requires high-performance and reliable concurrent systems code, for concurrent data structures, operating system kernels,Expand
A Better x86 Memory Model: x86-TSO (Extended Version)
TLDR
A new x86-TSO model is presented that is sound with respect to real processors, reflects better the vendor’s intentions, and is also better suited for programming. Expand
Understanding POWER multiprocessors
TLDR
An abstract-machine semantics that abstracts from most of the implementation detail but explains the behaviour of a range of subtle examples of IBM POWER multiprocessors is given, which should bring new clarity to concurrent systems programming for these architectures. Expand
The C11 and C++11 concurrency model
TLDR
This thesis provides a mechanised formal model of C and C++ concurrency, refinements to the design that removed major errors from the specification before ratification, a proof in HOL4 that the model supports a simpler interface for regular programmers, and an online tool for testing intuitions about the model. Expand
Multiprocessor Architectures Don’t Really Exist (But They Should)
Multiprocessors and high-level concurrent languages generally provide only relaxed (non-sequentiallyconsistent) memory models, to permit performance optimisations. One has to understand these modelsExpand
Relaxed-memory concurrency and verified compilation
TLDR
The semantic design and verified compilation of a C-like programming language for concurrent shared-memory computation above x86 multiprocessors is considered and a strategy for verifying compilation from ClightTSO to x86 is discussed. Expand
Reasoning about the Implementation of Concurrency Abstractions on x86-TSO
TLDR
A novel principle for reasoning about assembly programs on the previous x86-TSO memory model is developed, and it is used to analyze five concurrency abstraction implementations: two spinlocks; a non-blocking write protocol; the double-checked locking idiom; and java.util.concurrent's Parker. Expand
Memory, an elusive abstraction
TLDR
This talk will reflect on the experience of the colleagues and I in trying to establish usable models for x86 multiprocessors, where it appears that the x86-TSO model suffices for common-case code, and for Power and ARM multip rocessor models, where the authors have models that capture some but not all aspects of their behaviour. Expand
...
1
2
3
4
5
...

References

SHOWING 1-10 OF 33 REFERENCES
CheckFence: checking consistency of concurrent data types on relaxed memory models
TLDR
The CheckFence prototype automatically translates the C implementation code and the test program into a SAT formula, hands the latter to a standard SAT solver, and constructs counter example traces if there exist incorrect executions. Expand
Foundations of the C++ concurrency memory model
TLDR
The simple model the effort to address issues by explicitly providing semantics for threads in the next revision of the C++ standard is described, and how this, together with some practical, but often under-appreciated implementation constraints, drives us towards the above decisions. Expand
Reasoning about the ARM weakly consistent memory model
This paper describes a formalization of the ARM weakly consistent memory model: the architectural contract between parallel programs and shared memory multiprocessor implementations. We claim that aExpand
The Java memory model
TLDR
The new Java model provides a simple interface for correctly synchronized programs -- it guarantees sequential consistency to data-race-free programs and could prove to be a useful basis for other programming languages that currently lack well-defined models, such as C++ and C#. Expand
An executable specification, analyzer and verifier for RMO (relaxed memory order)
TLDR
The justification that the memory model specz~ed by ordering rules and its operational description are equivalent is discussed and howsynchroniza tion routines can be verijied and how finite state programs can reanalyzed is described. Expand
Effective Program Verification for Relaxed Memory Models
TLDR
A new verification technique for the most common relaxation, store buffers, that finds relaxed memory model bugs in several programs, including two previously unknown bugs in a production-level concurrency library that would have been difficult to find by other means. Expand
A theory of memory models
TLDR
All models in the framework satisfy the Fundamental Property of relaxed memory models: programs whose sequentially consistent (SC) executions have no races must have have only SC executions. Expand
The power of processor consistency
TLDR
This work uses a formal model to give two distinct definitions of processors consistency: one corresponding to Goodman’s original proposal and the other corresponding that given by the implementors of the DASH system. Expand
Formalising Java's Data Race Free Guarantee
TLDR
The data race free (DRF) guarantee provided by Java, as captured by the semi-formal Java Memory Model (JMM), is formalised and found that not all of the anticipated conditions in the JMM definition were actually necessary for the DRF guarantee. Expand
Information-Flow Models for Shared Memory with an Application to the PowerPC Architecture
TLDR
A generic framework for defining instructions, programs, and the semantics of their instantiation by operations in a multiprocessor environment that allows an architect to reveal the programming view induced by a shared-memory architecture and guides architecture-level verification. Expand
...
1
2
3
4
...