The C11 and C++11 Concurrency Model

Chapter 3
The formal C/C++ memory model
This chapter describes a mechanised formal definition of the C/C++11 memory model,
following the C++11 standard (Appendix A establishes a close link to the text). The
formal model was developed in discussion with the C++11 standardisation committee
during the drafting phases of the C++11 standard. This process brought to light several
major errors in drafts of the standard and led to solutions that were incorporated in the
ratified standards (Chapter 5 discusses these changes, together with remaining issues).
The close contact with the standardisation committee, the link to the standard text and
the fact that this model fed changes to the standard establish it as an authoritative
representation of the C++11 memory model. C11 adopts the same memory model as
C++11 for compatibility, so the model presented here applies to C as well.
The formal model relies on several simplifications. Details like alignment, bit representation,
and trap values are ignored, we assume variables are aligned and disjoint, signal
handlers are not modeled and neither is undefined behaviour introduced thread-locally:
e.g. division by zero, out-of-bound array accesses. We do not consider mixed size accesses
or allocation and deallocation of memory: both would require a memory-layout model
that is omitted for simplicity.
The memory model is introduced in stages, as a sequence of derivative models that
apply to successively more complete sublanguages of C/C++11. The mathematics that
describe the models is automatically typeset from the source, written in the Lem specification
language [90] (the full set of definitions are reproduced in Appendix C). The first
section introduces a cut-down version of the C/C++11 memory model that describes the
behaviour of straightforward single-threaded programs, and in doing so, introduces the
underlying types and top-level structure of the memory model that will apply to the rest
of the models in the chapter. This introductory section is followed by a series of formal
memory models that incrementally introduce concurrency features, together with the
mathematics that describe how they behave, and the underlying architectural intuitions
related to them. The chapter culminates in the presentation of the full formal model of
C/C++11 concurrency as defined by the ISO standard. The following table displays the
49