Optimize fill_bytes_via*

Author: pitdicker

rand_core/src/impls.rs

@@ -39,31 +39,45 @@ pub fn next_u64_via_u32<R: RngCore + ?Sized>(rng: &mut R) -> u64 {
 
 macro_rules! fill_bytes_via {
     ($rng:ident, $next_u:ident, $BYTES:expr, $dest:ident) => {{
+        // This method is optimized to only call `$next_u()` from one place in
+        // the loop, which helps to minimize the code size in combination with
+        // inlining. This has the consequence that if `$dest.len() == 0` it will
+        // also use a value from the RNG, instead of returning directly. We
+        // could handle it as a special case, but that could reduce the
+        // performance of all uses just to improve that of the non-sensical
+        // zero-length `$dest` scenario a little.
+        let remainder = $dest.len() % $BYTES;
+        let len = $dest.len() / $BYTES;
+
+        let mut read_len = 0;
         let mut left = $dest;
-        while left.len() >= $BYTES {
-            let (l, r) = {left}.split_at_mut($BYTES);
-            left = r;
-            let chunk: [u8; $BYTES] = unsafe {
+        let mut chunk: [u8; $BYTES];
+        loop {
+            chunk = unsafe {
                 transmute($rng.$next_u().to_le())
             };
-            l.copy_from_slice(&chunk);
+            if read_len < len {
+                let (l, r) = {left}.split_at_mut($BYTES);
+                left = r;
+                l.copy_from_slice(&chunk);
+                read_len += $BYTES;
+            }
+            if read_len == len { break; }
         }
-        let n = left.len();
-        if n > 0 {
-            let chunk: [u8; $BYTES] = unsafe {
-                transmute($rng.$next_u().to_le())
-            };
-            left.copy_from_slice(&chunk[..n]);
+        if remainder > 0 {
+            left.copy_from_slice(&chunk[..remainder]);
         }
     }}
 }
 
 /// Implement `fill_bytes` via `next_u32`, little-endian order.
+#[inline(always)]
 pub fn fill_bytes_via_u32<R: RngCore + ?Sized>(rng: &mut R, dest: &mut [u8]) {
     fill_bytes_via!(rng, next_u32, 4, dest)
 }
 
 /// Implement `fill_bytes` via `next_u64`, little-endian order.
+#[inline(always)]
 pub fn fill_bytes_via_u64<R: RngCore + ?Sized>(rng: &mut R, dest: &mut [u8]) {
     fill_bytes_via!(rng, next_u64, 8, dest)
 }