This page is a snapshot from the LWG issues list, see the Library Active Issues List for more information and the meaning of NAD status.

### 1473. Incomplete memory order specifications

Section: 33.5.8.2 [atomics.types.operations] Status: NAD Submitter: INCITS Opened: 2010-08-25 Last modified: 2016-01-28

Priority: Not Prioritized

View all other issues in [atomics.types.operations].

View all issues with NAD status.

Discussion:

Addresses US-172

As of 33.5.8.2 [atomics.types.operations] p. 9, 13, 17, 20:

The order specifications are incomplete because the non-`_explicit` functions do not have such parameters.

Add a new sentence: "If the program does not specify an order, it shall be `memory_order_seq_cst`." Or perhaps: "The non-_explicit non-member functions shall affect memory as though they were _explicit with `memory_order_seq_cst`."

[ 2010 Batavia ]

The Concurrency subgroup reviewed this, and deemed it NAD according to 33.5.8.2 [atomics.types.operations] paragraph 2, bullet 4.

Rationale:

The working paper is correct as written.

Proposed resolution:

1. Change 33.5.8.2 [atomics.types.operations] p. 9 as indicated:

   >     void atomic_store(volatile A* object, C desired);
   >     void atomic_store(A* object, C desired);
   >     void atomic_store_explicit(volatile A *object, C desired, memory_order order);
   >     void atomic_store_explicit(A* object, C desired, memory_order order);
   >     void A::store(C desired, memory_order order = memory_order_seq_cst) volatile;
   >     void A::store(C desired, memory_order order = memory_order_seq_cst);

   > > 8 Requires: The order argument shall not be `memory_order_consume`, `memory_order_acquire`, nor `memory_order_acq_rel`.

   > > 9 Effects: Atomically replaces the value pointed to by `object` or by this with the value of `desired`. Memory is affected according to the value of `order`. If the program does not specify an order, it shall be `memory_order_seq_cst`.

2. Change 33.5.8.2 [atomics.types.operations] p. 13 as indicated:

   >     C atomic_load(const volatile A* object);
   >     C atomic_load(const A* object);
   >     C atomic_load_explicit(const volatile A* object, memory_order);
   >     C atomic_load_explicit(const A* object, memory_order);
   >     C A::load(memory_order order = memory_order_seq_cst) const volatile;
   >     C A::load(memory_order order = memory_order_seq_cst) const;

   > > 12 Requires: The order argument shall not be `memory_order_release` nor `memory_order_acq_rel`.

   > > 13 Effects: Memory is affected according to the value of `order`. If the program does not specify an order, it shall be `memory_order_seq_cst`.

   > > 14 Returns: Atomically returns the value pointed to by `object` or by `this`.

3. Change 33.5.8.2 [atomics.types.operations] p. 17 as indicated:

   >     C atomic_exchange(volatile A* object, C desired);
   >     C atomic_exchange(A* object, C desired);
   >     C atomic_exchange_explicit(volatile A* object, C desired, memory_order);
   >     C atomic_exchange_explicit(A* object, C desired, memory_order);
   >     C A::exchange(C desired, memory_order order = memory_order_seq_cst) volatile;
   >     C A::exchange(C desired, memory_order order = memory_order_seq_cst);

   > > 17 Effects: Atomically replaces the value pointed to by `object` or by `this` with `desired`. Memory is affected according to the value of `order`. These operations are atomic read-modify-write operations (1.10). If the program does not specify an order, it shall be `memory_order_seq_cst`.

   > > 18 Returns: Atomically returns the value pointed to by `object` or by `this` immediately before the effects.

4. Change 33.5.8.2 [atomics.types.operations] p. 20 as indicated:

   >     bool atomic_compare_exchange_weak(volatile A* object, C * expected, C desired);
   >     bool atomic_compare_exchange_weak(A* object, C * expected, C desired);
   >     bool atomic_compare_exchange_strong(volatile A* object, C * expected, C desired);
   >     bool atomic_compare_exchange_strong(A* object, C * expected, C desired);
   >     bool atomic_compare_exchange_weak_explicit(volatile A* object, C * expected, C desired,
   >       memory_order success, memory_order failure);
   >     bool atomic_compare_exchange_weak_explicit(A* object, C * expected, C desired,
   >       memory_order success, memory_order failure);
   >     bool atomic_compare_exchange_strong_explicit(volatile A* object, C * expected, C desired,
   >       memory_order success, memory_order failure);
   >     bool atomic_compare_exchange_strong_explicit(A* object, C * expected, C desired,
   >       memory_order success, memory_order failure);
   >     bool A::compare_exchange_weak(C & expected, C desired,
   >       memory_order success, memory_order failure) volatile;
   >     bool A::compare_exchange_weak(C & expected, C desired,
   >       memory_order success, memory_order failure);
   >     bool A::compare_exchange_strong(C & expected, C desired,
   >       memory_order success, memory_order failure) volatile;
   >     bool A::compare_exchange_strong(C & expected, C desired,
   >       memory_order success, memory_order failure);
   >     bool A::compare_exchange_weak(C & expected, C desired,
   >       memory_order order = memory_order_seq_cst) volatile;
   >     bool A::compare_exchange_weak(C & expected, C desired,
   >       memory_order order = memory_order_seq_cst);
   >     bool A::compare_exchange_strong(C & expected, C desired,
   >       memory_order order = memory_order_seq_cst) volatile;
   >     bool A::compare_exchange_strong(C & expected, C desired,
   >       memory_order order = memory_order_seq_cst);

   > > 19 Requires: The `failure` argument shall not be `memory_order_release` nor `memory_order_acq_rel`. The `failure` argument shall be no stronger than the success argument.

   > > 20 Effects: Atomically, compares the contents of the memory pointed to by `object` or by `this` for equality with that in `expected`, and if true, replaces the contents of the memory pointed to by `object` or by `this` with that in `desired`, and if false, updates the contents of the memory in expected with the contents of the memory pointed to by `object` or by `this`. Further, if the comparison is true, memory is affected according to the value of `success`, and if the comparison is false, memory is affected according to the value of `failure`. When only one `memory_order` argument is supplied, the value of `success` is `order`, and the value of `failure` is `order` except that a value of `memory_order_acq_rel` shall be replaced by the value `memory_order_acquire` and a value of `memory_order_release` shall be replaced by the value `memory_order_relaxed`. If the program does not specify an order, it shall be `memory_order_seq_cst`. If the operation returns `true`, these operations are atomic read-modify-write operations (1.10). Otherwise, these operations are atomic load operations.

   > > [..]