Support multiple seed pools

simulator/src/main.rs

@@ -1,4 +1,4 @@
-use std::{borrow::Borrow, fs::File, io::Write, sync::{Arc, Mutex}};
+use std::{fs::File, io::Write, sync::{Arc, Mutex}};
 
 use board::Board;
 use ruleset::Ruleset;
@@ -16,28 +16,7 @@ mod zobrist;
 
 fn main() {
     /*
-    let mut rng = PicoRng::srand(0x20000);
-    for _ in 0..10 { 
-        println!("{}", rng.rnd(0x10000));
-    }
-    return;
-    */
-
-    /*
-    let ruleset = Ruleset { 
-        n_slots: 11, 
-        n_suits: 5, 
-        n_cards_per_suit: 10, 
-        n_arcana: 25 
-    };
-    */
-    let ruleset = Ruleset { 
-        n_slots: 11, 
-        n_suits: 4, 
-        n_cards_per_suit: 13, 
-        n_arcana: 22 
-    };
-    /* 
+    let filename = "level_1.txt";
     let ruleset = Ruleset { 
         n_slots: 5, 
         n_suits: 1, 
@@ -46,6 +25,16 @@ fn main() {
     };
     */
     /*
+    let filename = "level_2.txt";
+    let ruleset = Ruleset { 
+        n_slots: 5, 
+        n_suits: 2, 
+        n_cards_per_suit: 9, 
+        n_arcana: 0 
+    };
+    */
+    /* 
+    let filename = "level_3.txt";
     let ruleset = Ruleset { 
         n_slots: 7, 
         n_suits: 2, 
@@ -54,37 +43,61 @@ fn main() {
     };
     */
     /*
+    let filename = "level_4.txt";
+    let ruleset = Ruleset { 
+        n_slots: 9, 
+        n_suits: 3, 
+        n_cards_per_suit: 9, 
+        n_arcana: 16 
+    }; 
+    */
+    /*
+    let filename = "level_5.txt";
     let ruleset = Ruleset { 
         n_slots: 9, 
         n_suits: 3, 
         n_cards_per_suit: 11, 
         n_arcana: 18 
+    }; 
+    */
+    /*
+    let filename = "fortunes_foundation.txt";
+    let ruleset = Ruleset { 
+        n_slots: 11, 
+        n_suits: 4, 
+        n_cards_per_suit: 13, 
+        n_arcana: 22 
     };
     */
+
+    let filename = "level_7.txt";
+    let ruleset = Ruleset { 
+        n_slots: 11, 
+        n_suits: 5, 
+        n_cards_per_suit: 10, 
+        n_arcana: 25 
+    };
+
     let setup = ruleset.compile().expect("compilation should succeed");
-    /*
-    for _ in 0..10000 {
-        Deal::deal(&setup, &mut rand::thread_rng());
-    }
-    */
 
     const THREADS: usize = 28;
-    let winnable_seeds_file = Arc::new(Mutex::new(File::create("winnable_seeds_multithreaded.txt").expect("should be able to create")));
+    let work_source: WorkSource = WorkSource::new(0);
+    let winnable_seeds_file = Arc::new(Mutex::new(File::create(filename).expect("should be able to create")));
 
     let mut threads = Vec::new();
-    for i in 0..THREADS {
+    for _ in 0..THREADS {
         let setup2 = setup.clone();
+        let source = work_source.clone();
         let wsf = winnable_seeds_file.clone();
         threads.push(std::thread::spawn(move || {
             winnable_seeds_thread(
                 &setup2, 
+                source,
                 |seed| {
                     let mut f = wsf.lock().expect("must be able to lock");
                     write!(f, "{}\n", seed).expect("write should succeed");
                     f.flush().expect("flush should succeed");
                 },
-                i as u32, 
-                THREADS as u32
             );
         }));
     }
@@ -95,11 +108,31 @@ fn main() {
 
 }
 
-fn winnable_seeds_thread(setup: &ruleset::Setup, mut cb: impl FnMut(u32), start: u32, step: u32) {
+#[derive(Clone)]
+struct WorkSource {
+    seed: Arc<Mutex<Option<u32>>>
+}
+
+impl WorkSource {
+    fn new(seed: u32) -> Self {
+        return WorkSource { seed: Arc::new(Mutex::new(Some(seed))) }
+    }
+
+    fn take(&self) -> Option<u32> {
+        let mut self_seed = self.seed.lock().expect("shouldn't have panicked");
+        if let Some(seed) = *self_seed {
+            *self_seed = seed.checked_add(1);
+            return Some(seed);
+        }
+        return None
+    }
+}
+
+fn winnable_seeds_thread(setup: &ruleset::Setup, source: WorkSource, mut cb: impl FnMut(u32)) {
     let mut winnable = 0;
     let mut total = 0;
     
-    for seed in (start..0xffffffff).step_by(step as usize) {
+    while let Some(seed) = source.take() {
         let mut board = Board::new(&setup);
         board.deal(Deal::deal(&setup, seed));
         board.display();