Remove bytes_until_reseed field

Author: dhardy

Cargo.lock

@@ -84,3 +84,7 @@ rand_pcg = { path = "rand_pcg", version = "0.10.0-rc.1" }
 postcard = {version = "1.1.3", default-features = false, features = ["alloc"]}
 rayon = "1.7"
 serde_json = "1.0.140"
+
+[patch.crates-io.chacha20]
+git = "https://github.com/RustCrypto/stream-ciphers.git"
+rev = "8ae42d9ad47e9401d13a930e0ea62add2032a051"

Cargo.toml

@@ -8,7 +8,6 @@
 
 //! Thread-local random number generator
 
-use core::mem::size_of_val;
 use core::{cell::UnsafeCell, convert::Infallible};
 use std::fmt;
 use std::rc::Rc;
@@ -35,54 +34,45 @@ use rand_core::{TryCryptoRng, TryRng};
 
 // Number of generated bytes after which to reseed `ThreadRng`.
 // According to benchmarks, reseeding has a noticeable impact with thresholds
-// of 32 kB and less. We choose 64 kB to avoid significant overhead.
-const THREAD_RNG_RESEED_THRESHOLD: i64 = 1024 * 64;
+// of 32 kB and less. We choose 64 kB = 4096 blocks to avoid significant overhead.
+const RESEED_BLOCK_THRESHOLD: u64 = 4096;
 
 type Core = chacha20::ChaChaCore<chacha20::R12, chacha20::variants::Legacy>;
 type Results = <Core as Generator>::Output;
 
 struct ReseedingCore {
     inner: Core,
-    bytes_until_reseed: i64,
 }
 
 impl Generator for ReseedingCore {
     type Output = Results;
 
     fn generate(&mut self, results: &mut Results) {
-        if self.bytes_until_reseed <= 0 {
+        if self.inner.get_block_pos() >= RESEED_BLOCK_THRESHOLD {
             // We get better performance by not calling only `reseed` here
             // and continuing with the rest of the function, but by directly
             // returning from a non-inlined function.
             return self.reseed_and_generate(results);
         }
-        let num_bytes = size_of_val(results);
-        self.bytes_until_reseed -= num_bytes as i64;
         self.inner.generate(results);
     }
 }
 
 impl ReseedingCore {
     /// Reseed the internal PRNG.
     fn reseed(&mut self) -> Result<(), SysError> {
-        Core::try_from_rng(&mut SysRng).map(|result| {
-            self.bytes_until_reseed = THREAD_RNG_RESEED_THRESHOLD;
-            self.inner = result
-        })
+        Core::try_from_rng(&mut SysRng).map(|result| self.inner = result)
     }
 
     #[inline(never)]
     fn reseed_and_generate(&mut self, results: &mut Results) {
         trace!("Reseeding RNG (periodic reseed)");
 
-        let num_bytes = size_of_val(results);
-
         if let Err(e) = self.reseed() {
             warn!("Reseeding RNG failed: {}", e);
             let _ = e;
         }
 
-        self.bytes_until_reseed = THREAD_RNG_RESEED_THRESHOLD - num_bytes as i64;
         self.inner.generate(results);
     }
 }
@@ -171,7 +161,6 @@ thread_local!(
             inner: Core::try_from_rng(&mut SysRng).unwrap_or_else(|err| {
                 panic!("could not initialize ThreadRng: {}", err)
             }),
-            bytes_until_reseed: THREAD_RNG_RESEED_THRESHOLD,
         })))
     }
 );