Improve performance of isaac64::next_u32.

This does some crazy things with indexing, but is 45% faster. We are no longer
throwing away half of the results.

[Cherry-picked from 415ef6f]

Author: pitdicker

src/prng/isaac64.rs

@@ -136,6 +136,13 @@ impl Isaac64Rng {
     /// - We fill `rsl` backwards. The reference implementation reads values
     ///   from `rsl` in reverse. We read them in the normal direction, to make
     ///   `fill_bytes` a memcopy. To maintain compatibility we fill in reverse.
+    /// - We store `index` as if `rsl` contains `u32`'s instead of `u64`'s, plus
+    ///   one. This way we can make more efficient use of the generated results
+    ///   in `next_u32`.
+    ///   For `next_u32` the correct index is `index - 1`.
+    ///   For `next_u64` the correct index is `index >> 1`, which also takes
+    ///   care of any alignment issues that could arise if `next_u64` was called
+    ///   after `next_u32`.
     fn isaac64(&mut self) {
         self.c += w(1);
         // abbreviations
@@ -185,41 +192,63 @@ impl Isaac64Rng {
 
         self.a = a;
         self.b = b;
-        self.index = 0;
+        self.index = 1;
     }
 }
 
 impl Rng for Isaac64Rng {
     #[inline]
     fn next_u32(&mut self) -> u32 {
-        self.next_u64() as u32
+        // Using a local variable for `index`, and checking the size avoids a
+        // bounds check later on.
+        let mut index = self.index as usize - 1;
+        if index >= RAND_SIZE * 2 {
+            self.isaac64();
+            index = 0;
+        }
+
+        let value;
+        if cfg!(target_endian = "little") {
+            // Index as if this is a u32 slice.
+            let rsl = unsafe { &*(&mut self.rsl as *mut [u64; RAND_SIZE]
+                                                as *mut [u32; RAND_SIZE * 2]) };
+            value = rsl[index];
+        } else {
+            // Index into the u64 slice, rotate and truncate the result.
+            // Works always, also on big-endian systems, but is slower.
+            let tmp = self.rsl[index >> 1];
+            value = tmp as u32;
+            self.rsl[index >> 1] = tmp.rotate_right(32);
+        }
+        self.index += 1;
+        value
     }
 
     #[inline]
     fn next_u64(&mut self) -> u64 {
-        let mut index = self.index as usize;
+        let mut index = self.index as usize >> 1;
         if index >= RAND_SIZE {
             self.isaac64();
             index = 0;
         }
 
         let value = self.rsl[index];
-        self.index += 1;
+        self.index += 2;
         value
     }
 
     fn fill_bytes(&mut self, dest: &mut [u8]) {
         let mut read_len = 0;
         while read_len < dest.len() {
-            if self.index as usize >= RAND_SIZE {
+            if (self.index as usize >> 1) >= RAND_SIZE {
                 self.isaac64();
             }
 
             let (consumed_u64, filled_u8) =
-                impls::fill_via_u64_chunks(&mut self.rsl[(self.index as usize)..],
+                impls::fill_via_u64_chunks(&mut self.rsl[(self.index as usize >> 1)..],
                                            &mut dest[read_len..]);
 
-            self.index += consumed_u64 as u32;
+            self.index += consumed_u64 as u32 * 2;
             read_len += filled_u8;
         }
     }
@@ -386,20 +415,12 @@ mod test {
         let mut rng1 = Isaac64Rng::from_seed(seed);
         let v = (0..10).map(|_| rng1.next_u32()).collect::<Vec<_>>();
         // Subset of above values, as an LE u32 sequence
-        // TODO: switch to this sequence?
-//         assert_eq!(v,
-//                    [141028748, 127386717,
-//                     1058730652, 3347555894,
-//                     851491469, 4039984500,
-//                     2692730210, 288449107,
-//                     646103879, 2782923823]);
-        // Subset of above values, using only low-half of each u64
         assert_eq!(v,
-                   [141028748, 1058730652,
-                    851491469, 2692730210,
-                    646103879, 4195642895,
-                    2836348583, 1312677241,
-                    999139615, 253604626]);
+                   [141028748, 127386717,
+                    1058730652, 3347555894,
+                    851491469, 4039984500,
+                    2692730210, 288449107,
+                    646103879, 2782923823]);
     }
 
     #[test]