Implement transposition table. Currently battling borrow checker

Author: confusinguser

src/algorithms/mod.rs

@@ -1 +1,2 @@
 pub(crate) mod the_algorithm;
+pub(crate) mod utils;

src/algorithms/the_algorithm.rs

@@ -1,50 +1,88 @@
+use std::collections::HashMap;
 use std::time::Instant;
 
-use chess::{Action, Board, BoardStatus, Color, MoveGen};
+use chess::{Action, Board, BoardStatus, ChessMove, Color, MoveGen};
 
 use crate::common::constants::modules::*;
 use crate::common::utils::{self, Stats};
 
+use super::utils::{Evaluation, TranspositionEntry};
+
 pub(crate) struct Algorithm {
     pub(crate) modules: u32,
+    transposition_table: HashMap<Board, TranspositionEntry>,
 }
 
 impl Algorithm {
     pub(crate) fn new(modules: u32) -> Self {
-        Self { modules }
+        Self {
+            modules,
+            transposition_table: HashMap::new(),
+        }
     }
 
+    #[allow(clippy::too_many_arguments)]
     fn node_eval_recursive(
-        &self,
+        &mut self,
         board: &Board,
         depth: u32,
         mut alpha: f32,
         mut beta: f32,
         original: bool,
         deadline: Option<Instant>,
         stats: &mut Stats,
-    ) -> (Option<Action>, f32, Option<Vec<String>>) {
+    ) -> Evaluation {
         if depth == 0 {
             stats.leaves_visited += 1;
-            return (None, self.eval(board), None);
+            return Evaluation::new(self.eval(board), None, None);
         }
 
         // Whether we should try to maximise the eval
         let maximise: bool = board.side_to_move() == Color::White;
-        let mut best_eval = (None, if maximise { f32::MIN } else { f32::MAX }, None);
+        let mut best_evaluation =
+            Evaluation::new(if maximise { f32::MIN } else { f32::MAX }, None, None);
 
         let legal_moves = MoveGen::new_legal(board);
         let num_legal_moves = legal_moves.len();
-        if num_legal_moves == 0 && board.checkers().popcnt() == 0 {
-            // Is Stalemate, no checking pieces
-            best_eval = (None, 0., None)
+        if num_legal_moves == 0 {
+            if board.checkers().popcnt() == 0 {
+                // Is Stalemate, no checking pieces
+                best_evaluation.eval = 0.;
+            }
+            // If we arrive at here and it is checkmate, then we know that the side playing
+            // has been checkmated, and therefore the current `best_eval` is correct. Because if we tried to
+            // maximise, we failed, and if trying to minimise, we failed and therefore get the
+            // lowest/highest eval
+            println!("The thing happened");
+            return best_evaluation;
         }
-        // If we arrive at here and it is checkmate, then we know that the side playing
-        // has been checkmated, and therefore the current `best_eval` is correct. Because if we tried to
-        // maximise, we failed, and if trying to minimise, we failed and therefore get the
-        // lowest/highest eval
 
-        for (i, chess_move) in legal_moves.enumerate() {
+        let mut boards = legal_moves
+            .map(|chess_move| {
+                let board = board.make_move_new(chess_move);
+                let mut transposition_entry = None;
+                if self.modules & TRANSPOSITION_TABLE != 0 {
+                    transposition_entry = self.transposition_table.get(&board);
+                }
+                (chess_move, board, transposition_entry)
+            })
+            .collect::<Vec<(ChessMove, Board, Option<&TranspositionEntry>)>>();
+
+        // Sort by eval
+        boards.sort_by(|board1, board2| {
+            let ordering = board1
+                .2
+                .map_or(0., |entry| entry.eval)
+                .partial_cmp(&board2.2.map_or(0., |entry| entry.eval))
+                .expect("Eval is a valid value");
+
+            if !maximise {
+                return ordering.reverse();
+            }
+            ordering
+        });
+
+        for (i, (chess_move, new_board, transposition_entry)) in boards.iter().enumerate() {
             if deadline.map_or(false, |deadline| {
                 !Instant::now().saturating_duration_since(deadline).is_zero()
             }) {
@@ -53,57 +91,55 @@ impl Algorithm {
                 // node on our layer
                 stats.progress_on_next_layer *= 1. / num_legal_moves as f32;
                 stats.progress_on_next_layer += i as f32 / num_legal_moves as f32;
-                return best_eval;
+                return best_evaluation;
             };
 
-            let new_position = board.make_move_new(chess_move);
-            let eval = self.node_eval_recursive(
-                &new_position,
-                depth - 1,
-                alpha,
-                beta,
-                false,
-                deadline,
-                stats,
-            );
+            let evaluation = if transposition_entry.is_none()
+                || transposition_entry.unwrap().depth < depth
+            {
+                self.node_eval_recursive(new_board, depth - 1, alpha, beta, false, deadline, stats)
+            } else {
+                Evaluation::new(
+                    transposition_entry.unwrap().eval,
+                    transposition_entry.unwrap().next_action,
+                    None,
+                )
+            };
             stats.nodes_visited += 1;
 
-            if maximise && eval.1 > best_eval.1 || !maximise && eval.1 < best_eval.1 {
+            // Replace best_eval if ours is better
+            if maximise && evaluation.eval > best_evaluation.eval
+                || !maximise && evaluation.eval < best_evaluation.eval
+            {
                 if original && self.modules & ANALYZE != 0 {
                     let mut vec = Vec::new();
                     let new_best_move = chess_move.to_string();
-                    let new_best_eval = eval.1;
+                    let new_best_eval = evaluation.eval;
                     utils::vector_push_debug!(
                         vec,
                         self.modules,
                         maximise,
-                        best_eval.1,
+                        best_evaluation.eval,
                         new_best_move,
                         new_best_eval,
                     );
-                    if let Some(Action::MakeMove(previous_best_move)) = best_eval.0 {
+                    if let Some(Action::MakeMove(previous_best_move)) = best_evaluation.next_action
+                    {
                         let previous_best_move = previous_best_move.to_string();
                         utils::vector_push_debug!(vec, previous_best_move);
                     }
-                    best_eval.2 = Some(vec);
+                    best_evaluation.debug_data = Some(vec);
                 }
 
-                best_eval.1 = eval.1;
-                best_eval.0 = Some(Action::MakeMove(chess_move));
+                best_evaluation.eval = evaluation.eval;
+                best_evaluation.next_action = Some(Action::MakeMove(*chess_move));
             }
 
             if self.modules & ALPHA_BETA != 0 {
                 if maximise {
-                    // if eval.1 > alpha {
-                    // println!("Alpha changed. {} -> {}. Beta: {}", alpha, eval.1, beta);
-                    // }
-                    alpha = alpha.max(eval.1);
+                    alpha = alpha.max(evaluation.eval);
                 } else {
-                    // if eval.1 < beta {
-                    // println!("Beta changed. {} -> {}. Alpha: {}", beta, eval.1, alpha);
-                    // }
-
-                    beta = beta.min(eval.1);
+                    beta = beta.min(evaluation.eval);
                 }
 
                 if alpha > beta {
@@ -113,35 +149,50 @@ impl Algorithm {
             }
         }
 
-        best_eval
+        self.transposition_table.insert(
+            *board,
+            TranspositionEntry::new(depth, best_evaluation.eval, best_evaluation.next_action),
+        );
+        best_evaluation
     }
 
     fn next_action_internal(
-        &self,
+        &mut self,
         board: &Board,
         depth: u32,
         deadline: Option<Instant>,
     ) -> (chess::Action, Vec<String>, Stats) {
         let mut stats = Stats::default();
         let out =
             self.node_eval_recursive(board, depth, f32::MIN, f32::MAX, true, deadline, &mut stats);
-        let action = out.0.unwrap_or(Action::Resign(board.side_to_move()));
-        let analyzer_data = out.2.unwrap_or_default();
+        let action = if out.next_action.is_none() {
+            match board.status() {
+                BoardStatus::Ongoing => {
+                    panic!("No action returned by algorithm even though game is still ongoing")
+                }
+                BoardStatus::Stalemate => Action::DeclareDraw,
+                BoardStatus::Checkmate => Action::Resign(board.side_to_move()),
+            }
+        } else {
+            out.next_action.unwrap()
+        };
+        let analyzer_data = out.debug_data.unwrap_or_default();
         (action, analyzer_data, stats)
     }
 
     pub(crate) fn next_action(
-        &self,
+        &mut self,
         board: &Board,
         deadline: Instant,
     ) -> (chess::Action, Vec<String>, Stats) {
+        // Guarantee that at least the first layer gets done.
         const START_DEPTH: u32 = 1;
         let mut deepest_complete_output = self.next_action_internal(board, START_DEPTH, None);
         let mut deepest_complete_depth = START_DEPTH;
+
         for depth in (deepest_complete_depth + 1)..=10 {
             let latest_output = self.next_action_internal(board, depth, Some(deadline));
-            let time_since_deadline = Instant::now().saturating_duration_since(deadline);
-            if !time_since_deadline.is_zero() {
+            if utils::passed_deadline(deadline) {
                 // The cancelled layer is the one with this data
                 deepest_complete_output.2.progress_on_next_layer =
                     latest_output.2.progress_on_next_layer;

src/algorithms/utils.rs

@@ -0,0 +1,38 @@
+use chess::Action;
+
+#[derive(Debug, Copy, Clone)]
+pub(super) struct TranspositionEntry {
+    pub(super) depth: u32,
+    pub(super) eval: f32,
+    pub(super) next_action: Option<Action>,
+}
+
+impl TranspositionEntry {
+    pub(super) fn new(depth: u32, eval: f32, next_action: Option<Action>) -> Self {
+        TranspositionEntry {
+            depth,
+            eval,
+            next_action,
+        }
+    }
+}
+
+pub(super) struct Evaluation {
+    pub(super) debug_data: Option<Vec<String>>,
+    pub(super) eval: f32,
+    pub(super) next_action: Option<Action>,
+}
+
+impl Evaluation {
+    pub(super) fn new(
+        eval: f32,
+        next_action: Option<Action>,
+        debug_data: Option<Vec<String>>,
+    ) -> Evaluation {
+        Evaluation {
+            eval,
+            next_action,
+            debug_data,
+        }
+    }
+}

src/common/algorithm.rs

@@ -2,4 +2,6 @@ pub(crate) mod modules {
     pub(crate) const ANALYZE: u32 = 0b1;
     /// What bit the AB feature is in the modules integer
     pub(crate) const ALPHA_BETA: u32 = 0b10;
+
+    pub(crate) const TRANSPOSITION_TABLE: u32 = 0b100;
 }

src/common/constants.rs

@@ -1,3 +1,2 @@
-pub(crate) mod algorithm;
 pub(crate) mod constants;
 pub(crate) mod utils;

src/common/mod.rs

@@ -1,5 +1,5 @@
 use std::ops::{AddAssign, Div};
-use std::time::Duration;
+use std::time::{Duration, Instant};
 
 use chess::{Board, ChessMove, Color, Game, MoveGen, Piece};
 use rand::Rng;
@@ -115,6 +115,8 @@ impl Div<u32> for Stats {
     type Output = StatsAverage;
 }
 #[derive(Default, Debug)]
+// These fields are used through Debug
+#[allow(dead_code)]
 pub(crate) struct StatsAverage {
     pub(crate) alpha_beta_breaks: f32,
     pub(crate) depth: f32,
@@ -124,3 +126,8 @@ pub(crate) struct StatsAverage {
     pub(crate) time_spent: Duration,
     pub(crate) progress_on_next_layer: f32,
 }
+
+pub(crate) fn passed_deadline(deadline: Instant) -> bool {
+    let time_since_deadline = Instant::now().saturating_duration_since(deadline);
+    time_since_deadline.is_zero()
+}

src/common/utils.rs

@@ -1,5 +1,5 @@
 use crate::algorithms::the_algorithm::Algorithm;
-use crate::common::constants::modules::{ALPHA_BETA, ANALYZE};
+use crate::common::constants::modules::{ALPHA_BETA, ANALYZE, TRANSPOSITION_TABLE};
 
 use self::pitter::logic::Competition;
 
@@ -8,8 +8,8 @@ mod common;
 mod pitter;
 
 fn main() {
-    let modules1 = ALPHA_BETA | ANALYZE;
-    let modules2 = ANALYZE;
+    let modules1 = TRANSPOSITION_TABLE | ALPHA_BETA | ANALYZE;
+    let modules2 = ALPHA_BETA | ANALYZE;
 
     let mut competition = Competition::new(Algorithm::new(modules1), Algorithm::new(modules2));
 

src/main.rs

@@ -113,10 +113,15 @@ impl Competition {
         }
     }
 
-    pub(crate) fn play_game(&self, mut game: Game, reversed: bool, max_plies: usize) -> GameInfo {
+    pub(crate) fn play_game(
+        &mut self,
+        mut game: Game,
+        reversed: bool,
+        max_plies: usize,
+    ) -> GameInfo {
         let mut game_info = GameInfo::default();
-        let mut algo1 = &self.algo1;
-        let mut algo2 = &self.algo2;
+        let mut algo1 = &mut self.algo1;
+        let mut algo2 = &mut self.algo2;
         if reversed {
             mem::swap(&mut algo1, &mut algo2);
         };
@@ -191,7 +196,7 @@ impl Competition {
         game_info
     }
 
-    fn play_game_pair(&self, game: Game) -> (GameInfo, GameInfo) {
+    fn play_game_pair(&mut self, game: Game) -> (GameInfo, GameInfo) {
         let outcome1 = self.play_game(game.clone(), false, 150);
         let outcome2 = self.play_game(game, true, 150);
 
@@ -247,7 +252,7 @@ impl Competition {
         self.algo1.eval(&board) + self.algo2.eval(&board) / 2.
     }
 
-    pub(crate) fn find_game<P>(&self, predicate: P) -> Option<(GameInfo, GameInfo)>
+    pub(crate) fn find_game<P>(&mut self, predicate: P) -> Option<(GameInfo, GameInfo)>
     where
         P: Fn(&(GameInfo, GameInfo), GamePairOutcome) -> bool,
     {
@@ -271,7 +276,7 @@ impl Competition {
         }
     }
 
-    pub(crate) fn analyze_algorithm_choices<P>(&self, predicate: P)
+    pub(crate) fn analyze_algorithm_choices<P>(&mut self, predicate: P)
     where
         P: Fn(&(GameInfo, GameInfo), GamePairOutcome) -> bool,
     {