Merging upstream version 1.72.1+dfsg1.

Signed-off-by: Daniel Baumann <daniel.baumann@progress-linux.org>

1 files changed, 59 insertions, 28 deletions

diff --git a/vendor/tokio/src/util/rand.rs b/vendor/tokio/src/util/rand.rs
index 17b3ec1ae..d96c8d37e 100644
--- a/vendor/tokio/src/util/rand.rs
+++ b/vendor/tokio/src/util/rand.rs
@@ -1,21 +1,43 @@
-use std::cell::Cell;
+cfg_rt! {
+    mod rt;
+    pub(crate) use rt::RngSeedGenerator;
 
-/// Fast random number generate
+    cfg_unstable! {
+        mod rt_unstable;
+    }
+}
+
+/// A seed for random number generation.
+///
+/// In order to make certain functions within a runtime deterministic, a seed
+/// can be specified at the time of creation.
+#[allow(unreachable_pub)]
+#[derive(Clone, Debug)]
+pub struct RngSeed {
+    s: u32,
+    r: u32,
+}
+
+/// Fast random number generate.
 ///
 /// Implement xorshift64+: 2 32-bit xorshift sequences added together.
 /// Shift triplet `[17,7,16]` was calculated as indicated in Marsaglia's
 /// Xorshift paper: <https://www.jstatsoft.org/article/view/v008i14/xorshift.pdf>
 /// This generator passes the SmallCrush suite, part of TestU01 framework:
 /// <http://simul.iro.umontreal.ca/testu01/tu01.html>
-#[derive(Debug)]
+#[derive(Clone, Copy, Debug)]
 pub(crate) struct FastRand {
-    one: Cell<u32>,
-    two: Cell<u32>,
+    one: u32,
+    two: u32,
 }
 
-impl FastRand {
-    /// Initialize a new, thread-local, fast random number generator.
-    pub(crate) fn new(seed: u64) -> FastRand {
+impl RngSeed {
+    /// Creates a random seed using loom internally.
+    pub(crate) fn new() -> Self {
+        Self::from_u64(crate::loom::rand::seed())
+    }
+
+    fn from_u64(seed: u64) -> Self {
         let one = (seed >> 32) as u32;
         let mut two = seed as u32;
 
@@ -24,41 +46,50 @@ impl FastRand {
             two = 1;
         }
 
+        Self::from_pair(one, two)
+    }
+
+    fn from_pair(s: u32, r: u32) -> Self {
+        Self { s, r }
+    }
+}
+
+impl FastRand {
+    /// Initialize a new fast random number generator using the default source of entropy.
+    pub(crate) fn new() -> FastRand {
+        FastRand::from_seed(RngSeed::new())
+    }
+
+    /// Initializes a new, thread-local, fast random number generator.
+    pub(crate) fn from_seed(seed: RngSeed) -> FastRand {
         FastRand {
-            one: Cell::new(one),
-            two: Cell::new(two),
+            one: seed.s,
+            two: seed.r,
         }
     }
 
-    pub(crate) fn fastrand_n(&self, n: u32) -> u32 {
+    #[cfg(any(
+        feature = "macros",
+        feature = "rt-multi-thread",
+        all(feature = "sync", feature = "rt")
+    ))]
+    pub(crate) fn fastrand_n(&mut self, n: u32) -> u32 {
         // This is similar to fastrand() % n, but faster.
         // See https://lemire.me/blog/2016/06/27/a-fast-alternative-to-the-modulo-reduction/
         let mul = (self.fastrand() as u64).wrapping_mul(n as u64);
         (mul >> 32) as u32
     }
 
-    fn fastrand(&self) -> u32 {
-        let mut s1 = self.one.get();
-        let s0 = self.two.get();
+    fn fastrand(&mut self) -> u32 {
+        let mut s1 = self.one;
+        let s0 = self.two;
 
         s1 ^= s1 << 17;
         s1 = s1 ^ s0 ^ s1 >> 7 ^ s0 >> 16;
 
-        self.one.set(s0);
-        self.two.set(s1);
+        self.one = s0;
+        self.two = s1;
 
         s0.wrapping_add(s1)
     }
 }
-
-// Used by the select macro and `StreamMap`
-#[cfg(any(feature = "macros"))]
-#[doc(hidden)]
-#[cfg_attr(not(feature = "macros"), allow(unreachable_pub))]
-pub fn thread_rng_n(n: u32) -> u32 {
-    thread_local! {
-        static THREAD_RNG: FastRand = FastRand::new(crate::loom::rand::seed());
-    }
-
-    THREAD_RNG.with(|rng| rng.fastrand_n(n))
-}