race: Reduce success ordering from AcqRel to Release.

See the analogous change in rust-lang/rust#131746 and
the discussion in matklad#220.

What is the effect of this change? Consider this example:

```diff
 #[no_mangle]
 fn foo1(y: &mut i32) -> bool {
-    let r = X.compare_exchange(0, 1, Ordering::AcqRel, Ordering::Acquire).is_ok();
+    let r = X.compare_exchange(0, 1, Ordering::Release, Ordering::Acquire).is_ok();
     r
 }

```

On x86_64, there is no change. Here is the generated code before and after:

```
foo1:
        mov     rcx, qword ptr [rip + example::X::h9e1b81da80078af7@GOTPCREL]
        mov     edx, 1
        xor     eax, eax
        lock            cmpxchg dword ptr [rcx], edx
        sete    al
        ret

example::X::h9e1b81da80078af7:
        .zero   4
```

On AArch64, regardless of whether atomics are outlined or not, there is no change. Here
is the generated code with inlined atomics:

```
foo1:
        adrp    x8, :got:example::X::h40b04fb69d714de3
        ldr     x8, [x8, :got_lo12:example::X::h40b04fb69d714de3]
.LBB0_1:
        ldaxr   w9, [x8]
        cbnz    w9, .LBB0_4
        mov     w0, matklad#1
        stlxr   w9, w0, [x8]
        cbnz    w9, .LBB0_1
        ret
.LBB0_4:
        mov     w0, wzr
        clrex
        ret

example::X::h40b04fb69d714de3:
        .zero   4
```

For 32-bit ARMv7, with inlined atomics, the resulting diff in the object code is:

```diff
@@ -10,14 +10,13 @@
         mov     r0, matklad#1
         strex   r2, r0, [r1]
         cmp     r2, #0
-        beq     .LBB0_5
+        bxeq    lr
         ldrex   r0, [r1]
         cmp     r0, #0
         beq     .LBB0_2
 .LBB0_4:
-        mov     r0, #0
         clrex
-.LBB0_5:
+        mov     r0, #0
         dmb     ish
         bx      lr
 .LCPI0_0:
@@ -54,4 +53,3 @@

 example::X::h47e2038445e1c648:
         .zero   4
```

Author: briansmith

src/race.rs

@@ -81,8 +81,14 @@ impl OnceNonZeroUsize {
     /// full.
     #[inline]
     pub fn set(&self, value: NonZeroUsize) -> Result<(), ()> {
+        // The module documentation promises "happens-before" semantics. On
+        // success, the value was zero, so there is nothing to acquire (there
+        // is never any `Ordering::Release` store of 0). On failure, the value
+        // was nonzero, so it was initialized previously (perhaps on another
+        // thread) using `Ordering::Release`; use `Ordering::Acquire` to
+        // ensure that store "happens-before" this load.
         let exchange =
-            self.inner.compare_exchange(0, value.get(), Ordering::AcqRel, Ordering::Acquire);
+            self.inner.compare_exchange(0, value.get(), Ordering::Release, Ordering::Acquire);
         match exchange {
             Ok(_) => Ok(()),
             Err(_) => Err(()),
@@ -128,7 +134,13 @@ impl OnceNonZeroUsize {
     #[inline(never)]
     fn init<E>(&self, f: impl FnOnce() -> Result<NonZeroUsize, E>) -> Result<NonZeroUsize, E> {
         let mut val = f()?.get();
-        let exchange = self.inner.compare_exchange(0, val, Ordering::AcqRel, Ordering::Acquire);
+        // The module documentation promises "happens-before" semantics. On
+        // success, the value was zero, so there is nothing to acquire (there
+        // is never any `Ordering::Release` store of 0). On failure, the value
+        // was nonzero, so it was initialized previously (perhaps on another
+        // thread) using `Ordering::Release`; use `Ordering::Acquire` to
+        // ensure that store "happens-before" this load.
+        let exchange = self.inner.compare_exchange(0, val, Ordering::Release, Ordering::Acquire);
         if let Err(old) = exchange {
             val = old;
         }
@@ -241,8 +253,14 @@ impl<'a, T> OnceRef<'a, T> {
     /// full.
     pub fn set(&self, value: &'a T) -> Result<(), ()> {
         let ptr = value as *const T as *mut T;
+        // The module documentation promises "happens-before" semantics. On
+        // success, the value was null, so there is nothing to acquire (there
+        // is never any `Ordering::Release` store of null). On failure, the
+        // value was non-null, so it was initialized previously (perhaps on
+        // another thread) using `Ordering::Release`; use `Ordering::Acquire`
+        // to ensure that store "happens-before" this load.
         let exchange =
-            self.inner.compare_exchange(ptr::null_mut(), ptr, Ordering::AcqRel, Ordering::Acquire);
+            self.inner.compare_exchange(ptr::null_mut(), ptr, Ordering::Release, Ordering::Acquire);
         match exchange {
             Ok(_) => Ok(()),
             Err(_) => Err(()),
@@ -282,10 +300,16 @@ impl<'a, T> OnceRef<'a, T> {
         if ptr.is_null() {
             // TODO replace with `cast_mut` when MSRV reaches 1.65.0 (also in `set`)
             ptr = f()? as *const T as *mut T;
+            // The module documentation promises "happens-before" semantics. On
+            // success, the value was null, so there is nothing to acquire (there
+            // is never any `Ordering::Release` store of null). On failure, the
+            // value was non-null, so it was initialized previously (perhaps on
+            // another thread) using `Ordering::Release`; use `Ordering::Acquire`
+            // to ensure that store "happens-before" this load.
             let exchange = self.inner.compare_exchange(
                 ptr::null_mut(),
                 ptr,
-                Ordering::AcqRel,
+                Ordering::Release,
                 Ordering::Acquire,
             );
             if let Err(old) = exchange {
@@ -377,10 +401,16 @@ mod once_box {
         /// full.
         pub fn set(&self, value: Box<T>) -> Result<(), Box<T>> {
             let ptr = Box::into_raw(value);
+            // The module documentation promises "happens-before" semantics. On
+            // success, the value was null, so there is nothing to acquire (there
+            // is never any `Ordering::Release` store of null). On failure, the
+            // value was non-null, so it was initialized previously (perhaps on
+            // another thread) using `Ordering::Release` so use `Ordering::Acquire`
+            // to ensure that store "happens-before" this load.
             let exchange = self.inner.compare_exchange(
                 ptr::null_mut(),
                 ptr,
-                Ordering::AcqRel,
+                Ordering::Release,
                 Ordering::Acquire,
             );
             if exchange.is_err() {
@@ -423,10 +453,16 @@ mod once_box {
             if ptr.is_null() {
                 let val = f()?;
                 ptr = Box::into_raw(val);
+                // The module documentation promises "happens-before" semantics. On
+                // success, the value was null, so there is nothing to acquire (there
+                // is never any `Ordering::Release` store of null). On failure, the
+                // value was non-null, so it was initialized previously (perhaps on
+                // another thread) using `Ordering::Release` so use `Ordering::Acquire`
+                // to ensure that store "happens-before" this load.
                 let exchange = self.inner.compare_exchange(
                     ptr::null_mut(),
                     ptr,
-                    Ordering::AcqRel,
+                    Ordering::Release,
                     Ordering::Acquire,
                 );
                 if let Err(old) = exchange {