Add SMP Support

datagen/src/lib.rs

@@ -41,7 +41,7 @@ pub struct Destination {
 
 impl Destination {
     pub fn push(&mut self, game: &Binpack, stop: &AtomicBool) {
-        if stop.load(Ordering::SeqCst) {
+        if stop.load(Ordering::Relaxed) {
             return;
         }
 
@@ -51,7 +51,7 @@ impl Destination {
         game.serialise_into(&mut self.writer).unwrap();
 
         if self.games >= self.limit {
-            stop.store(true, Ordering::SeqCst);
+            stop.store(true, Ordering::Relaxed);
             return;
         }
 

datagen/src/thread.rs

@@ -118,29 +118,22 @@ impl<'a> DatagenThread<'a> {
             }
 
             let abort = AtomicBool::new(false);
-            let mut searcher = Searcher::new(
-                position.clone(),
-                tree,
-                self.params.clone(),
-                policy,
-                value,
-                &abort,
-            );
+            tree.try_use_subtree(&position, &None);
+            let searcher =
+                Searcher::new(position.clone(), &tree, &self.params, policy, value, &abort);
 
-            let (bm, score) = searcher.search(limits, false, &mut 0, &None);
+            let (bm, score) = searcher.search(1, limits, false, &mut 0);
 
             game.push(position.stm(), bm, score);
 
-            tree = searcher.tree_and_board().0;
-
             let mut root_count = 0;
             position.map_legal_moves(|_| root_count += 1);
 
             // disallow positions with >106 moves and moves when in check
             if root_count <= 112 {
                 let mut policy_pos = PolicyData::new(position.clone(), bm, score);
 
-                for action in tree[tree.root_node()].actions() {
+                for action in tree[tree.root_node()].actions().iter() {
                     policy_pos.push(action.mov().into(), action.visits());
                 }
 

src/chess.rs

@@ -19,6 +19,32 @@ pub enum GameState {
     Won(u8),
 }
 
+impl From<GameState> for u16 {
+    fn from(value: GameState) -> Self {
+        match value {
+            GameState::Ongoing => 0,
+            GameState::Draw => 1 << 8,
+            GameState::Lost(x) => (2 << 8) ^ u16::from(x),
+            GameState::Won(x) => (3 << 8) ^ u16::from(x),
+        }
+    }
+}
+
+impl From<u16> for GameState {
+    fn from(value: u16) -> Self {
+        let discr = value >> 8;
+        let x = value as u8;
+
+        match discr {
+            0 => GameState::Ongoing,
+            1 => GameState::Draw,
+            2 => GameState::Lost(x),
+            3 => GameState::Won(x),
+            _ => unreachable!(),
+        }
+    }
+}
+
 impl std::fmt::Display for GameState {
     fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
         match self {