Migrate to new rand_core utility functions

Cargo.toml

@@ -76,7 +76,8 @@ exclude = ["benches", "distr_test"]
 rand_core = { version = "0.10.0-rc-2", default-features = false }
 log = { version = "0.4.4", optional = true }
 serde = { version = "1.0.103", features = ["derive"], optional = true }
-chacha20 = { version = "=0.10.0-rc.5", default-features = false, features = ["rng"], optional = true }
+# chacha20 = { version = "=0.10.0-rc.5", default-features = false, features = ["rng"], optional = true }
+chacha20 = { path = "rand_chacha", optional = true, package = "rand_chacha" }
 getrandom = { version = "0.3.0", optional = true }
 
 [dev-dependencies]
@@ -85,3 +86,6 @@ rand_pcg = { path = "rand_pcg", version = "0.10.0-rc.1" }
 bincode = "1.2.1"
 rayon = "1.7"
 serde_json = "1.0.140"
+
+[patch.crates-io]
+rand_core = { git = "https://github.com/rust-random/rand_core", branch = "block_buffer" }

benches/Cargo.toml

@@ -15,7 +15,6 @@ rand = { path = "..", features = ["small_rng", "nightly"] }
 rand_pcg = { path = "../rand_pcg" }
 rand_chacha = { path = "../rand_chacha" }
 criterion = "0.5"
-criterion-cycles-per-byte = "0.6"
 
 [[bench]]
 name = "array"
@@ -56,3 +55,6 @@ harness = false
 [[bench]]
 name = "weighted"
 harness = false
+
+[patch.crates-io]
+rand_core = { git = "https://github.com/rust-random/rand_core", branch = "block_buffer" }

benches/benches/generators.rs

@@ -13,7 +13,7 @@ use rand::prelude::*;
 use rand::rngs::OsRng;
 use rand::rngs::ReseedingRng;
 use rand_chacha::rand_core::UnwrapErr;
-use rand_chacha::{ChaCha8Rng, ChaCha12Rng, ChaCha20Core, ChaCha20Rng};
+use rand_chacha::{ChaCha8Rng, ChaCha12Rng, ChaCha20Rng};
 use rand_pcg::{Pcg32, Pcg64, Pcg64Dxsm, Pcg64Mcg};
 
 criterion_group!(
@@ -198,7 +198,7 @@ pub fn reseeding_bytes(c: &mut Criterion) {
     fn bench(g: &mut BenchmarkGroup<WallTime>, thresh: u64) {
         let name = format!("chacha20_{thresh}k");
         g.bench_function(name.as_str(), |b| {
-            let mut rng = ReseedingRng::<ChaCha20Core, _>::new(thresh * 1024, OsRng).unwrap();
+            let mut rng = ReseedingRng::<ChaCha20Rng, _>::new(thresh * 1024, OsRng).unwrap();
             let mut buf = [0u8; 1024 * 1024];
             b.iter(|| {
                 rng.fill_bytes(&mut buf);

rand_chacha/src/chacha.rs

@@ -10,8 +10,7 @@
 
 use crate::guts::ChaCha;
 use core::fmt;
-use rand_core::block::{BlockRng, BlockRngCore, CryptoBlockRng};
-use rand_core::{CryptoRng, RngCore, SeedableRng};
+use rand_core::{CryptoRng, RngCore, SeedableRng, le::BlockBuffer};
 
 #[cfg(feature = "serde")]
 use serde::{Deserialize, Deserializer, Serialize, Serializer};
@@ -21,52 +20,6 @@ const BUF_BLOCKS: u8 = 4;
 // number of 32-bit words per ChaCha block (fixed by algorithm definition)
 const BLOCK_WORDS: u8 = 16;
 
-#[repr(transparent)]
-pub struct Array64<T>([T; 64]);
-impl<T> Default for Array64<T>
-where
-    T: Default,
-{
-    #[rustfmt::skip]
-    fn default() -> Self {
-        Self([
-            T::default(), T::default(), T::default(), T::default(), T::default(), T::default(), T::default(), T::default(),
-            T::default(), T::default(), T::default(), T::default(), T::default(), T::default(), T::default(), T::default(),
-            T::default(), T::default(), T::default(), T::default(), T::default(), T::default(), T::default(), T::default(),
-            T::default(), T::default(), T::default(), T::default(), T::default(), T::default(), T::default(), T::default(),
-            T::default(), T::default(), T::default(), T::default(), T::default(), T::default(), T::default(), T::default(),
-            T::default(), T::default(), T::default(), T::default(), T::default(), T::default(), T::default(), T::default(),
-            T::default(), T::default(), T::default(), T::default(), T::default(), T::default(), T::default(), T::default(),
-            T::default(), T::default(), T::default(), T::default(), T::default(), T::default(), T::default(), T::default(),
-        ])
-    }
-}
-impl<T> AsRef<[T]> for Array64<T> {
-    fn as_ref(&self) -> &[T] {
-        &self.0
-    }
-}
-impl<T> AsMut<[T]> for Array64<T> {
-    fn as_mut(&mut self) -> &mut [T] {
-        &mut self.0
-    }
-}
-impl<T> Clone for Array64<T>
-where
-    T: Copy + Default,
-{
-    fn clone(&self) -> Self {
-        let mut new = Self::default();
-        new.0.copy_from_slice(&self.0);
-        new
-    }
-}
-impl<T> fmt::Debug for Array64<T> {
-    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
-        write!(f, "Array64 {{}}")
-    }
-}
-
 macro_rules! chacha_impl {
     ($ChaChaXCore:ident, $ChaChaXRng:ident, $rounds:expr, $doc:expr, $abst:ident,) => {
         #[doc=$doc]
@@ -82,29 +35,28 @@ macro_rules! chacha_impl {
             }
         }
 
-        impl BlockRngCore for $ChaChaXCore {
-            type Item = u32;
-            type Results = Array64<u32>;
-
+        impl $ChaChaXCore {
+            /// Create new core state from seed.
             #[inline]
-            fn generate(&mut self, r: &mut Self::Results) {
-                self.state.refill4($rounds, &mut r.0);
+            pub fn from_seed(seed: [u8; 32]) -> Self {
+                $ChaChaXCore {
+                    state: ChaCha::new(&seed, &[0u8; 8]),
+                }
             }
-        }
 
-        impl SeedableRng for $ChaChaXCore {
-            type Seed = [u8; 32];
+            /// Generate next block.
+            #[inline]
+            pub fn next_block(&mut self, r: &mut [u32; 64]) {
+                self.state.refill4($rounds, r);
+            }
 
+            /// Get current block position.
             #[inline]
-            fn from_seed(seed: Self::Seed) -> Self {
-                $ChaChaXCore {
-                    state: ChaCha::new(&seed, &[0u8; 8]),
-                }
+            pub fn block_pos(&self) -> u64 {
+                self.state.get_block_pos()
             }
         }
 
-        impl CryptoBlockRng for $ChaChaXCore {}
-
         /// A cryptographically secure random number generator that uses the ChaCha algorithm.
         ///
         /// ChaCha is a stream cipher designed by Daniel J. Bernstein[^1], that we use as an RNG. It is
@@ -136,7 +88,7 @@ macro_rules! chacha_impl {
         /// ```
         ///
         /// This implementation uses an output buffer of sixteen `u32` words, and uses
-        /// [`BlockRng`] to implement the [`RngCore`] methods.
+        /// them to implement the [`RngCore`] methods.
         ///
         /// [^1]: D. J. Bernstein, [*ChaCha, a variant of Salsa20*](
         ///       https://cr.yp.to/chacha.html)
@@ -145,35 +97,54 @@ macro_rules! chacha_impl {
         ///       http://www.ecrypt.eu.org/stream/)
         #[derive(Clone, Debug)]
         pub struct $ChaChaXRng {
-            rng: BlockRng<$ChaChaXCore>,
+            core: $ChaChaXCore,
+            buffer: BlockBuffer<u32, 64>,
+        }
+
+        impl $ChaChaXRng {
+            #[inline]
+            fn buffer_index(&self) -> u32 {
+                self.buffer.index()
+            }
+
+            #[inline]
+            fn generate_and_set(&mut self, index: usize) {
+                if index == 0 {
+                    self.buffer.reset();
+                } else {
+                    self.buffer
+                        .generate_and_set(index, |block| self.core.next_block(block));
+                }
+            }
         }
 
         impl SeedableRng for $ChaChaXRng {
             type Seed = [u8; 32];
 
             #[inline]
             fn from_seed(seed: Self::Seed) -> Self {
-                let core = $ChaChaXCore::from_seed(seed);
                 Self {
-                    rng: BlockRng::new(core),
+                    core: $ChaChaXCore::from_seed(seed),
+                    buffer: BlockBuffer::default(),
                 }
             }
         }
 
         impl RngCore for $ChaChaXRng {
             #[inline]
             fn next_u32(&mut self) -> u32 {
-                self.rng.next_u32()
+                self.buffer.next_word(|block| self.core.next_block(block))
             }
 
             #[inline]
             fn next_u64(&mut self) -> u64 {
-                self.rng.next_u64()
+                self.buffer.next_u64(|block| self.core.next_block(block))
             }
 
             #[inline]
-            fn fill_bytes(&mut self, bytes: &mut [u8]) {
-                self.rng.fill_bytes(bytes)
+            fn fill_bytes(&mut self, dst: &mut [u8]) {
+                self.buffer
+                    .fill_bytes(dst, |block| self.core.next_block(block));
             }
         }
 
@@ -190,11 +161,11 @@ macro_rules! chacha_impl {
             #[inline]
             pub fn get_word_pos(&self) -> u128 {
                 let buf_start_block = {
-                    let buf_end_block = self.rng.core.state.get_block_pos();
+                    let buf_end_block = self.core.state.get_block_pos();
                     u64::wrapping_sub(buf_end_block, BUF_BLOCKS.into())
                 };
                 let (buf_offset_blocks, block_offset_words) = {
-                    let buf_offset_words = self.rng.index() as u64;
+                    let buf_offset_words = self.buffer_index() as u64;
                     let blocks_part = buf_offset_words / u64::from(BLOCK_WORDS);
                     let words_part = buf_offset_words % u64::from(BLOCK_WORDS);
                     (blocks_part, words_part)
@@ -212,9 +183,8 @@ macro_rules! chacha_impl {
             #[inline]
             pub fn set_word_pos(&mut self, word_offset: u128) {
                 let block = (word_offset / u128::from(BLOCK_WORDS)) as u64;
-                self.rng.core.state.set_block_pos(block);
-                self.rng
-                    .generate_and_set((word_offset % u128::from(BLOCK_WORDS)) as usize);
+                self.core.state.set_block_pos(block);
+                self.generate_and_set((word_offset % u128::from(BLOCK_WORDS)) as usize);
             }
 
             /// Set the stream number.
@@ -230,8 +200,8 @@ macro_rules! chacha_impl {
             /// indirectly via `set_word_pos`), but this is not directly supported.
             #[inline]
             pub fn set_stream(&mut self, stream: u64) {
-                self.rng.core.state.set_nonce(stream);
-                if self.rng.index() != 64 {
+                self.core.state.set_nonce(stream);
+                if self.buffer_index() != 64 {
                     let wp = self.get_word_pos();
                     self.set_word_pos(wp);
                 }
@@ -240,13 +210,13 @@ macro_rules! chacha_impl {
             /// Get the stream number.
             #[inline]
             pub fn get_stream(&self) -> u64 {
-                self.rng.core.state.get_nonce()
+                self.core.state.get_nonce()
             }
 
             /// Get the seed.
             #[inline]
             pub fn get_seed(&self) -> [u8; 32] {
-                self.rng.core.state.get_seed()
+                self.core.state.get_seed()
             }
         }
 
@@ -255,7 +225,8 @@ macro_rules! chacha_impl {
         impl From<$ChaChaXCore> for $ChaChaXRng {
             fn from(core: $ChaChaXCore) -> Self {
                 $ChaChaXRng {
-                    rng: BlockRng::new(core),
+                    core,
+                    buffer: BlockBuffer::default(),
                 }
             }
         }

rand_chacha/src/lib.rs

@@ -13,9 +13,8 @@
 //!
 //! ## Generators
 //!
-//! This crate provides 8-, 12- and 20-round variants of generators via a "core"
-//! implementation (of [`BlockRngCore`]), each with an associated "RNG" type
-//! (implementing [`RngCore`]).
+//! This crate provides 8-, 12- and 20-round variants of generators
+//! implementing [`RngCore`].
 //!
 //! These generators are all deterministic and portable (see [Reproducibility]
 //! in the book), with testing against reference vectors.
@@ -73,7 +72,6 @@
 //! [Seeding RNGs]: https://rust-random.github.io/book/guide-seeding.html
 //! [Security]: https://rust-random.github.io/book/guide-rngs.html#security
 //! [Random Values]: https://rust-random.github.io/book/guide-values.html
-//! [`BlockRngCore`]: rand_core::block::BlockRngCore
 //! [`RngCore`]: rand_core::RngCore
 //! [`SeedableRng`]: rand_core::SeedableRng
 //! [`OsRng`]: https://docs.rs/rand/latest/rand/rngs/struct.OsRng.html

rand_pcg/src/pcg128.rs

@@ -126,10 +126,9 @@ impl SeedableRng for Lcg128Xsl64 {
     /// We use a single 255-bit seed to initialise the state and select a stream.
     /// One `seed` bit (lowest bit of `seed[8]`) is ignored.
     fn from_seed(seed: Self::Seed) -> Self {
-        let mut seed_u64 = [0u64; 4];
-        le::read_u64_into(&seed, &mut seed_u64);
-        let state = u128::from(seed_u64[0]) | (u128::from(seed_u64[1]) << 64);
-        let incr = u128::from(seed_u64[2]) | (u128::from(seed_u64[3]) << 64);
+        let seed: [u64; 4] = le::read_words(&seed);
+        let state = u128::from(seed[0]) | (u128::from(seed[1]) << 64);
+        let incr = u128::from(seed[2]) | (u128::from(seed[3]) << 64);
 
         // The increment must be odd, hence we discard one bit:
         Lcg128Xsl64::from_state_incr(state, incr | 1)
@@ -150,7 +149,7 @@ impl RngCore for Lcg128Xsl64 {
 
     #[inline]
     fn fill_bytes(&mut self, dest: &mut [u8]) {
-        le::fill_bytes_via_next(self, dest)
+        le::fill_bytes_via_next_word(dest, || self.next_u64())
     }
 }
 
@@ -232,9 +231,8 @@ impl SeedableRng for Mcg128Xsl64 {
 
     fn from_seed(seed: Self::Seed) -> Self {
         // Read as if a little-endian u128 value:
-        let mut seed_u64 = [0u64; 2];
-        le::read_u64_into(&seed, &mut seed_u64);
-        let state = u128::from(seed_u64[0]) | (u128::from(seed_u64[1]) << 64);
+        let seed: [u64; 2] = le::read_words(&seed);
+        let state = u128::from(seed[0]) | (u128::from(seed[1]) << 64);
         Mcg128Xsl64::new(state)
     }
 }
@@ -253,7 +251,7 @@ impl RngCore for Mcg128Xsl64 {
 
     #[inline]
     fn fill_bytes(&mut self, dest: &mut [u8]) {
-        le::fill_bytes_via_next(self, dest)
+        le::fill_bytes_via_next_word(dest, || self.next_u64())
     }
 }
 

rand_pcg/src/pcg128cm.rs

@@ -131,10 +131,9 @@ impl SeedableRng for Lcg128CmDxsm64 {
     /// We use a single 255-bit seed to initialise the state and select a stream.
     /// One `seed` bit (lowest bit of `seed[8]`) is ignored.
     fn from_seed(seed: Self::Seed) -> Self {
-        let mut seed_u64 = [0u64; 4];
-        le::read_u64_into(&seed, &mut seed_u64);
-        let state = u128::from(seed_u64[0]) | (u128::from(seed_u64[1]) << 64);
-        let incr = u128::from(seed_u64[2]) | (u128::from(seed_u64[3]) << 64);
+        let seed: [u64; 4] = le::read_words(&seed);
+        let state = u128::from(seed[0]) | (u128::from(seed[1]) << 64);
+        let incr = u128::from(seed[2]) | (u128::from(seed[3]) << 64);
 
         // The increment must be odd, hence we discard one bit:
         Self::from_state_incr(state, incr | 1)
@@ -156,7 +155,7 @@ impl RngCore for Lcg128CmDxsm64 {
 
     #[inline]
     fn fill_bytes(&mut self, dest: &mut [u8]) {
-        le::fill_bytes_via_next(self, dest)
+        le::fill_bytes_via_next_word(dest, || self.next_u64())
     }
 }
 

rand_pcg/src/pcg64.rs

@@ -127,11 +127,9 @@ impl SeedableRng for Lcg64Xsh32 {
     /// We use a single 127-bit seed to initialise the state and select a stream.
     /// One `seed` bit (lowest bit of `seed[8]`) is ignored.
     fn from_seed(seed: Self::Seed) -> Self {
-        let mut seed_u64 = [0u64; 2];
-        le::read_u64_into(&seed, &mut seed_u64);
-
+        let [state, increment] = le::read_words(&seed);
         // The increment must be odd, hence we discard one bit:
-        Lcg64Xsh32::from_state_incr(seed_u64[0], seed_u64[1] | 1)
+        Lcg64Xsh32::from_state_incr(state, increment | 1)
     }
 }
 
@@ -159,6 +157,6 @@ impl RngCore for Lcg64Xsh32 {
 
     #[inline]
     fn fill_bytes(&mut self, dest: &mut [u8]) {
-        le::fill_bytes_via_next(self, dest)
+        le::fill_bytes_via_next_word(dest, || self.next_u32())
     }
 }