Faster approach using custom modulo function

Author: maneatingape

README.md

@@ -313,7 +313,7 @@ Performance is reasonable even on older hardware, for example a 2011 MacBook Pro
 | 12 | [Digital Plumber](https://adventofcode.com/2017/day/12) | [Source](src/year2017/day12.rs) | 61 |
 | 13 | [Packet Scanners](https://adventofcode.com/2017/day/13) | [Source](src/year2017/day13.rs) | 1 |
 | 14 | [Disk Defragmentation](https://adventofcode.com/2017/day/14) | [Source](src/year2017/day14.rs) | 438 |
-| 15 | [Dueling Generators](https://adventofcode.com/2017/day/15) | [Source](src/year2017/day15.rs) | 26000 |
+| 15 | [Dueling Generators](https://adventofcode.com/2017/day/15) | [Source](src/year2017/day15.rs) | 20000 |
 | 16 | [Permutation Promenade](https://adventofcode.com/2017/day/16) | [Source](src/year2017/day16.rs) | 68 |
 | 17 | [Spinlock](https://adventofcode.com/2017/day/17) | [Source](src/year2017/day17.rs) | 85 |
 | 18 | [Duet](https://adventofcode.com/2017/day/18) | [Source](src/year2017/day18.rs) | 7 |

src/year2017/day15.rs

@@ -14,6 +14,7 @@ use std::sync::atomic::{AtomicBool, AtomicUsize, Ordering};
 use std::sync::mpsc::{Receiver, Sender, channel};
 use std::thread;
 
+const MOD: usize = 0x7fffffff;
 const PART_ONE: usize = 40_000_000;
 const PART_TWO: usize = 5_000_000;
 const BLOCK: usize = 50_000;
@@ -63,8 +64,8 @@ fn sender(shared: &Shared, tx: &Sender<Block>) {
     while !shared.done.load(Ordering::Relaxed) {
         // Start at any point in the sequence using modular exponentiation.
         let start = shared.start.fetch_add(BLOCK, Ordering::Relaxed);
-        let mut first = shared.first * 16807.mod_pow(start, 0x7fffffff);
-        let mut second = shared.second * 48271.mod_pow(start, 0x7fffffff);
+        let mut first = shared.first * 16807.mod_pow(start, MOD);
+        let mut second = shared.second * 48271.mod_pow(start, MOD);
 
         // Estimate capacity at one quarter or one eight, plus a little extra for variance.
         let mut ones = 0;
@@ -73,8 +74,8 @@ fn sender(shared: &Shared, tx: &Sender<Block>) {
 
         // Check part one pairs immediately while queueing part two pairs.
         for _ in 0..BLOCK {
-            first = (first * 16807) % 0x7fffffff;
-            second = (second * 48271) % 0x7fffffff;
+            first = fast_mod(first * 16807);
+            second = fast_mod(second * 48271);
 
             let left = first as u16;
             let right = second as u16;
@@ -167,3 +168,11 @@ fn receiver(shared: &Shared, rx: &Receiver<Block>) -> (u32, u32) {
     let part_one = blocks.iter().take(PART_ONE / BLOCK).map(|p| p.ones).sum();
     (part_one, part_two)
 }
+
+#[inline]
+fn fast_mod(n: usize) -> usize {
+    let low = n & MOD;
+    let high = n >> 31;
+    let sum = low + high;
+    if sum < MOD { sum } else { sum - MOD }
+}