Wordsmithing & polishing

* Changes:

- Align the description of all 3 ways on the most structured form.
- Use atomic operation when mentioning Acquire or Release, and otherwise
  atomic read or atomic write, as appropriate.

* Motivation:

As per code review feedback, the most structured form is the preferred
form.

Furthermore, during the switch, it was noted that the use of read/load
or write/store was inconsistent. Since cppreference use the terms
read/written to refer to the Relaxed atomic operations, the terms
read/write are now used: they have the benefit of applying equally well
to load/store and to RMW operations.

Author: matthieu-m

library/core/src/sync/atomic.rs

@@ -4292,10 +4292,13 @@ unsafe fn atomic_umin<T: Copy>(dst: *mut T, val: T, order: Ordering) -> T {
 ///
 /// An atomic operation on one thread will synchronize with a fence on another thread when:
 ///
-/// -   An atomic operation 'X' with (at least) [`Release`] ordering semantics on some atomic object
-/// 'm' on thread 1,
-/// -   is paired on thread 2 with an atomic read 'Y' with any order on 'm',
-/// -   followed by a fence 'B' with (at least) [`Acquire`] ordering semantics.
+/// -   on thread 1:
+///     -   an atomic operation 'X' with (at least) [`Release`] ordering semantics on some atomic
+///         object 'm',
+///
+/// -   is paired on thread 2 with:
+///     -   an atomic read 'Y' with any order on 'm',
+///     -   followed by a fence 'B' with (at least) [`Acquire`] ordering semantics.
 ///
 /// This provides a happens-before dependence between X and B.
 ///
@@ -4315,12 +4318,12 @@ unsafe fn atomic_umin<T: Copy>(dst: *mut T, val: T, order: Ordering) -> T {
 ///
 /// A fence on one thread will synchronize with an atomic operation on another thread when:
 ///
-/// -   a fence 'A' with (at least) [`Release`] ordering semantics,
-/// -   followed by an atomic store 'X' with any ordering on some atomic object 'm',
-///
-/// on thread 1 is paired on thread 2 with:
+/// -   on thread:
+///     -   a fence 'A' with (at least) [`Release`] ordering semantics,
+///     -   followed by an atomic write 'X' with any ordering on some atomic object 'm',
 ///
-/// -   an atomic operation 'Y' with (at least) [`Acquire`] ordering semantics.
+/// -   is paired on thread 2 with:
+///     -   an atomic operation 'Y' with (at least) [`Acquire`] ordering semantics.
 ///
 /// This provides a happens-before dependence between A and Y.
 ///
@@ -4342,10 +4345,10 @@ unsafe fn atomic_umin<T: Copy>(dst: *mut T, val: T, order: Ordering) -> T {
 ///
 /// -   on thread 1:
 ///     -   a fence 'A' which has (at least) [`Release`] ordering semantics,
-///     -   followed by an atomic store 'X' with any ordering on some atomic object 'm',
+///     -   followed by an atomic write 'X' with any ordering on some atomic object 'm',
 ///
-/// -   is paired on thread 2:
-///     -   an atomic operation 'Y' with any ordering on 'm',
+/// -   is paired on thread 2 with:
+///     -   an atomic read 'Y' with any ordering on 'm',
 ///     -   followed by a fence 'B' with (at least) [`Acquire`] ordering semantics.
 ///
 /// This provides a happens-before dependence between A and B.