Support select! for no-std

Targets without libstd (and thus thread-local storage) now use global
xorshift state for the select order, which has been weakened for <64bit
targets.

Author: arcnmx

futures-util/src/async_await/mod.rs

@@ -26,17 +26,13 @@ mod join_mod;
 pub use self::join_mod::*;
 
 // Primary export is a macro
-#[cfg(feature = "std")]
 #[cfg(feature = "select-macro")]
 mod select_mod;
-#[cfg(feature = "std")]
 #[cfg(feature = "select-macro")]
 pub use self::select_mod::*;
 
-#[cfg(feature = "std")]
 #[cfg(feature = "select-macro")]
 mod random;
-#[cfg(feature = "std")]
 #[cfg(feature = "select-macro")]
 pub use self::random::*;
 

futures-util/src/async_await/random.rs

@@ -1,9 +1,9 @@
+use core::sync::atomic::{AtomicUsize, Ordering};
+#[cfg(feature = "std")]
 use std::{
     cell::Cell,
     collections::hash_map::DefaultHasher,
     hash::Hasher,
-    num::Wrapping,
-    sync::atomic::{AtomicUsize, Ordering},
 };
 
 // Based on [Fisher–Yates shuffle].
@@ -18,18 +18,15 @@ pub fn shuffle<T>(slice: &mut [T]) {
 
 /// Return a value from `0..n`.
 fn gen_index(n: usize) -> usize {
-    (random() % n as u64) as usize
+    random() % n
 }
 
-/// Pseudorandom number generator based on [xorshift*].
+/// Pseudorandom number generator based on [xorshift].
 ///
-/// [xorshift*]: https://en.wikipedia.org/wiki/Xorshift#xorshift*
-fn random() -> u64 {
-    thread_local! {
-        static RNG: Cell<Wrapping<u64>> = Cell::new(Wrapping(prng_seed()));
-    }
-
-    fn prng_seed() -> u64 {
+/// [xorshift]: https://en.wikipedia.org/wiki/Xorshift
+fn random() -> usize {
+    #[cfg(feature = "std")]
+    fn prng_seed() -> usize {
         static COUNTER: AtomicUsize = AtomicUsize::new(0);
 
         // Any non-zero seed will do
@@ -39,16 +36,75 @@ fn random() -> u64 {
             hasher.write_usize(COUNTER.fetch_add(1, Ordering::Relaxed));
             seed = hasher.finish();
         }
-        seed
+        seed as usize
     }
 
-    RNG.with(|rng| {
-        let mut x = rng.get();
-        debug_assert_ne!(x.0, 0);
+    #[cfg(not(feature = "std"))]
+    const fn prng_seed() -> usize {
+        // A deterministic seed is used in absense of TLS
+        42
+    }
+
+    /// [xorshift*] is used on 64bit platforms.
+    ///
+    /// [xorshift*]: https://en.wikipedia.org/wiki/Xorshift#xorshift*
+    #[cfg(target_pointer_width = "64")]
+    fn xorshift(mut x: usize) -> (usize, usize) {
+        debug_assert_ne!(x, 0);
         x ^= x >> 12;
         x ^= x << 25;
         x ^= x >> 27;
-        rng.set(x);
-        x.0.wrapping_mul(0x2545_f491_4f6c_dd1d)
-    })
+        (
+            x,
+            x.wrapping_mul(0x2545_f491_4f6c_dd1d),
+        )
+    }
+
+    /// [xorshift32] is used on 32bit platforms.
+    ///
+    /// [xorshift32]: https://en.wikipedia.org/wiki/Xorshift
+    #[cfg(target_pointer_width = "32")]
+    fn xorshift(mut x: usize) -> (usize, usize) {
+        debug_assert_ne!(x, 0);
+        x ^= x << 13;
+        x ^= x >> 17;
+        x ^= x << 5;
+        (x, x)
+    }
+
+    /// A non-standard xorshift variant is used on 16bit platforms.
+    #[cfg(target_pointer_width = "16")]
+    fn xorshift(mut x: usize) -> (usize, usize) {
+        // Constants chosen from: http://b2d-f9r.blogspot.com/2010/08/16-bit-xorshift-rng.html
+        debug_assert_ne!(x, 0);
+        x ^= x << 4;
+        x ^= x >> 3;
+        x ^= x << 7;
+        (x, x)
+    }
+
+    #[cfg(feature = "std")]
+    fn rng() -> usize {
+        thread_local! {
+            static RNG: Cell<usize> = Cell::new(prng_seed());
+        }
+
+        RNG.with(|rng| {
+            let (x, res) = xorshift(rng.get());
+            rng.set(x);
+            res
+        })
+    }
+
+    #[cfg(not(feature = "std"))]
+    fn rng() -> usize {
+        static RNG: AtomicUsize = AtomicUsize::new(prng_seed());
+
+        // Preemption here can cause multiple threads to observe repeated state
+        let (x, res) = xorshift(RNG.load(Ordering::Relaxed));
+        RNG.store(x, Ordering::Relaxed);
+        res
+    }
+
+    rng()
 }