Complete implementation of transposition table. Currently performing

worse than just AB-pruning for some reason

Author: confusinguser

src/algorithms/the_algorithm.rs

@@ -1,23 +1,25 @@
 use std::collections::HashMap;
-use std::time::Instant;
+use std::time::{Duration, Instant};
 
 use chess::{Action, Board, BoardStatus, ChessMove, Color, MoveGen};
 
 use crate::common::constants::modules::*;
-use crate::common::utils::{self, Stats};
+use crate::common::utils::{self, module_enabled, Stats};
 
 use super::utils::{Evaluation, TranspositionEntry};
 
 pub(crate) struct Algorithm {
     pub(crate) modules: u32,
     transposition_table: HashMap<Board, TranspositionEntry>,
+    pub(crate) time_per_move: Duration,
 }
 
 impl Algorithm {
-    pub(crate) fn new(modules: u32) -> Self {
+    pub(crate) fn new(modules: u32, time_per_move: Duration) -> Self {
         Self {
             modules,
             transposition_table: HashMap::new(),
+            time_per_move,
         }
     }
 
@@ -34,84 +36,100 @@ impl Algorithm {
     ) -> Evaluation {
         if depth == 0 {
             stats.leaves_visited += 1;
-            return Evaluation::new(self.eval(board), None, None);
+            let eval = self.eval(board);
+            // if module_enabled(self.modules, TRANSPOSITION_TABLE) {
+            //     let start = Instant::now();
+            //     self.transposition_table
+            //         .insert(*board, TranspositionEntry::new(depth, eval, None));
+            //     stats.time_for_transposition_access += Instant::now() - start;
+            //     stats.transposition_table_entries += 1
+            // }
+            return Evaluation::new(Some(eval), None, None);
         }
 
         // Whether we should try to maximise the eval
         let maximise: bool = board.side_to_move() == Color::White;
-        let mut best_evaluation =
-            Evaluation::new(if maximise { f32::MIN } else { f32::MAX }, None, None);
+        let mut best_evaluation = Evaluation::new(None, None, None);
 
         let legal_moves = MoveGen::new_legal(board);
         let num_legal_moves = legal_moves.len();
         if num_legal_moves == 0 {
             if board.checkers().popcnt() == 0 {
                 // Is Stalemate, no checking pieces
-                best_evaluation.eval = 0.;
+                best_evaluation.eval = Some(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");
+            // has been checkmated.
+
+            best_evaluation.eval = Some(if board.side_to_move() == Color::White {
+                f32::MIN
+            } else {
+                f32::MAX
+            });
             return best_evaluation;
         }
 
         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);
+                if module_enabled(self.modules, TRANSPOSITION_TABLE) {
+                    let start = Instant::now();
+
+                    transposition_entry = self.transposition_table.get(&board).copied();
+
+                    let time_for_transposition_access = Instant::now() - start;
+                    stats.time_for_transposition_access += time_for_transposition_access;
                 }
                 (chess_move, board, transposition_entry)
             })
-            .collect::<Vec<(ChessMove, Board, Option<&TranspositionEntry>)>>();
+            .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
-        });
+        // boards.sort_by(|board1, board2| {
+        //     let eval1 = board1.2.map_or(self.eval(&board1.1), |entry| entry.eval);
+        //     let eval2 = board2.2.map_or(self.eval(&board2.1), |entry| entry.eval);
+        //     let ordering = eval1.partial_cmp(&eval2).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()
-            }) {
+            if deadline.is_some_and(utils::passed_deadline) {
                 // The previous value of progress_on_next_layer comes from deeper layers returning.
                 // We want these contributions to be proportional to the contribution from a single
                 // 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;
+                stats.progress_on_next_layer +=
+                    (i.saturating_sub(1)) as f32 / num_legal_moves as f32;
                 return best_evaluation;
             };
 
-            let evaluation = if transposition_entry.is_none()
-                || transposition_entry.unwrap().depth < depth
+            let evaluation = if transposition_entry.is_some()
+                && transposition_entry.unwrap().depth >= depth
             {
-                self.node_eval_recursive(new_board, depth - 1, alpha, beta, false, deadline, stats)
-            } else {
+                stats.transposition_table_accesses += 1;
                 Evaluation::new(
-                    transposition_entry.unwrap().eval,
+                    Some(transposition_entry.unwrap().eval),
                     transposition_entry.unwrap().next_action,
                     None,
                 )
+            } else {
+                self.node_eval_recursive(new_board, depth - 1, alpha, beta, false, deadline, stats)
             };
             stats.nodes_visited += 1;
 
             // Replace best_eval if ours is better
-            if maximise && evaluation.eval > best_evaluation.eval
-                || !maximise && evaluation.eval < best_evaluation.eval
+            if evaluation.eval.is_some()
+                && (best_evaluation.eval.is_none()
+                    || maximise && evaluation.eval.unwrap() > best_evaluation.eval.unwrap()
+                    || !maximise && evaluation.eval.unwrap() < best_evaluation.eval.unwrap())
             {
-                if original && self.modules & ANALYZE != 0 {
+                if original && module_enabled(self.modules, ANALYZE) {
                     let mut vec = Vec::new();
                     let new_best_move = chess_move.to_string();
                     let new_best_eval = evaluation.eval;
@@ -135,11 +153,13 @@ impl Algorithm {
                 best_evaluation.next_action = Some(Action::MakeMove(*chess_move));
             }
 
-            if self.modules & ALPHA_BETA != 0 {
-                if maximise {
-                    alpha = alpha.max(evaluation.eval);
-                } else {
-                    beta = beta.min(evaluation.eval);
+            if module_enabled(self.modules, ALPHA_BETA) {
+                if let Some(eval) = evaluation.eval {
+                    if maximise {
+                        alpha = alpha.max(eval);
+                    } else {
+                        beta = beta.min(eval);
+                    }
                 }
 
                 if alpha > beta {
@@ -149,10 +169,25 @@ impl Algorithm {
             }
         }
 
-        self.transposition_table.insert(
-            *board,
-            TranspositionEntry::new(depth, best_evaluation.eval, best_evaluation.next_action),
-        );
+        if module_enabled(self.modules, TRANSPOSITION_TABLE) && depth >= 3 {
+            if let Some(best_eval) = best_evaluation.eval {
+                let start = Instant::now();
+                self.transposition_table.insert(
+                    *board,
+                    TranspositionEntry::new(depth, best_eval, best_evaluation.next_action),
+                );
+                stats.time_for_transposition_access += Instant::now() - start;
+            }
+            stats.transposition_table_entries += 1
+        }
+
+        if best_evaluation.debug_data.is_some() {
+            let mut debug_data = best_evaluation.debug_data.take().unwrap();
+            if let Some(Action::MakeMove(next_move)) = best_evaluation.next_action {
+                utils::vector_push_debug!(debug_data, best_evaluation.eval, next_move.to_string(),);
+                best_evaluation.debug_data = Some(debug_data);
+            }
+        }
         best_evaluation
     }
 
@@ -161,23 +196,12 @@ impl Algorithm {
         board: &Board,
         depth: u32,
         deadline: Option<Instant>,
-    ) -> (chess::Action, Vec<String>, Stats) {
+    ) -> (Option<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 = 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)
+        (out.next_action, analyzer_data, stats)
     }
 
     pub(crate) fn next_action(
@@ -203,7 +227,24 @@ impl Algorithm {
             }
         }
         deepest_complete_output.2.depth = deepest_complete_depth;
-        deepest_complete_output
+        deepest_complete_output.2.tt_size = self.transposition_table.len() as u32;
+
+        (
+            match deepest_complete_output.0 {
+                Some(action) => action,
+                None => match board.status() {
+                    BoardStatus::Ongoing => {
+                        println!("{}", board);
+                        println!("{:#?}", deepest_complete_output.1);
+                        panic!("No action returned by algorithm even though game is still ongoing")
+                    }
+                    BoardStatus::Stalemate => Action::DeclareDraw,
+                    BoardStatus::Checkmate => Action::Resign(board.side_to_move()),
+                },
+            },
+            deepest_complete_output.1,
+            deepest_complete_output.2,
+        )
     }
 
     pub(crate) fn eval(&self, board: &Board) -> f32 {
@@ -224,4 +265,8 @@ impl Algorithm {
         let diff = material_each_side.0 as i32 - material_each_side.1 as i32;
         diff as f32
     }
+
+    pub(crate) fn reset(&mut self) {
+        self.transposition_table = HashMap::new();
+    }
 }

src/algorithms/utils.rs

@@ -17,15 +17,16 @@ impl TranspositionEntry {
     }
 }
 
+#[derive(Debug)]
 pub(super) struct Evaluation {
     pub(super) debug_data: Option<Vec<String>>,
-    pub(super) eval: f32,
+    pub(super) eval: Option<f32>,
     pub(super) next_action: Option<Action>,
 }
 
 impl Evaluation {
     pub(super) fn new(
-        eval: f32,
+        eval: Option<f32>,
         next_action: Option<Action>,
         debug_data: Option<Vec<String>>,
     ) -> Evaluation {

src/common/utils.rs

@@ -85,6 +85,10 @@ pub(crate) struct Stats {
     pub(crate) num_plies: u32,
     pub(crate) time_spent: Duration,
     pub(crate) progress_on_next_layer: f32,
+    pub(crate) transposition_table_entries: u32,
+    pub(crate) transposition_table_accesses: u32,
+    pub(crate) time_for_transposition_access: Duration,
+    pub(crate) tt_size: u32,
 }
 
 impl AddAssign for Stats {
@@ -96,6 +100,10 @@ impl AddAssign for Stats {
         self.num_plies += rhs.num_plies;
         self.time_spent += rhs.time_spent;
         self.progress_on_next_layer += rhs.progress_on_next_layer;
+        self.transposition_table_entries += rhs.transposition_table_entries;
+        self.transposition_table_accesses += rhs.transposition_table_accesses;
+        self.time_for_transposition_access += rhs.time_for_transposition_access;
+        self.tt_size += rhs.tt_size;
     }
 }
 
@@ -109,6 +117,10 @@ impl Div<u32> for Stats {
             num_plies: self.num_plies as f32 / rhs as f32,
             time_spent: self.time_spent / rhs,
             progress_on_next_layer: self.progress_on_next_layer / rhs as f32,
+            transposition_table_entries: self.transposition_table_entries as f32 / rhs as f32,
+            transposition_table_accesses: self.transposition_table_accesses as f32 / rhs as f32,
+            time_for_transposition_access: self.time_for_transposition_access / rhs,
+            tt_size: self.tt_size as f32 / rhs as f32,
         }
     }
 
@@ -125,9 +137,17 @@ pub(crate) struct StatsAverage {
     pub(crate) num_plies: f32,
     pub(crate) time_spent: Duration,
     pub(crate) progress_on_next_layer: f32,
+    pub(crate) transposition_table_entries: f32,
+    pub(crate) transposition_table_accesses: f32,
+    pub(crate) time_for_transposition_access: Duration,
+    pub(crate) tt_size: f32,
 }
 
 pub(crate) fn passed_deadline(deadline: Instant) -> bool {
     let time_since_deadline = Instant::now().saturating_duration_since(deadline);
-    time_since_deadline.is_zero()
+    !time_since_deadline.is_zero()
+}
+
+pub(crate) fn module_enabled(modules: u32, module_to_test: u32) -> bool {
+    modules & module_to_test != 0
 }

src/main.rs

@@ -1,3 +1,5 @@
+use std::time::Duration;
+
 use crate::algorithms::the_algorithm::Algorithm;
 use crate::common::constants::modules::{ALPHA_BETA, ANALYZE, TRANSPOSITION_TABLE};
 
@@ -10,10 +12,15 @@ mod pitter;
 fn main() {
     let modules1 = TRANSPOSITION_TABLE | ALPHA_BETA | ANALYZE;
     let modules2 = ALPHA_BETA | ANALYZE;
+    let time_per_move1 = Duration::from_micros(2000);
+    let time_per_move2 = Duration::from_micros(2000);
 
-    let mut competition = Competition::new(Algorithm::new(modules1), Algorithm::new(modules2));
+    let mut competition = Competition::new(
+        Algorithm::new(modules1, time_per_move1),
+        Algorithm::new(modules2, time_per_move2),
+    );
 
     // let results = competition.analyze_algorithm_choices(|_, _| true);
-    let results = competition.start_competition();
+    let results = competition.start_competition(200);
     dbg!(results);
 }