Added first depth multi threading to the bot

Author: shashankp28

.gitignore

@@ -193,3 +193,4 @@ tmp/
 *.csv
 *.html
 *zip
+pgn/

Cargo.toml

@@ -28,3 +28,4 @@ once_cell = "1.21.3"
 tar = "0.4.44"
 rand = "*"
 lru = "*"
+rayon = "*"

bots/mystic-bot

@@ -110,7 +110,7 @@ def __init__(self, *args, **kwargs):
         self.timeout = 60  # Not used
         self.timeRemaining = 0
         self.fenVals = []
-        self.server_url = "http://localhost:8080"
+        self.server_url = "http://localhost:2832"
 
     def set_chess_board(self, board: chess.Board):
         self.chessBoard = board

homemade.py

@@ -1,6 +1,6 @@
 use axum::{ extract::{ State, Json }, response::IntoResponse, http::StatusCode };
 use serde::{ Deserialize, Serialize };
-use std::{ str::FromStr, sync::Arc};
+use std::{ str::FromStr, sync::Arc, time::Instant };
 use chess::Board;
 use crate::bot::{
     algorithm::root::search,
@@ -17,30 +17,32 @@ use crate::bot::{
 pub struct EvalRequest {
     pub current_fen: String,
     pub history: Vec<String>,
-    time_left_ms: u128,
-    time_limit_ms: Option<u128>,
+    pub time_left_ms: u128,
+    pub time_limit_ms: Option<u128>,
 }
 
 #[derive(Debug, Serialize)]
 pub struct BestMoveResponse {
-    pub best_move: Option<String>,
-    pub eval: i32,
-    pub nodes: u64,
-    pub time: u128,
-    pub depth: u8,
+    pub best_move: String,
+    pub line: Vec<String>, // Full principal variation in UCI format
+    pub eval: i32, // Evaluation score
+    pub nodes: u64, // Total nodes searched
+    pub time: u128, // Time taken in milliseconds
+    pub depth: u8, // Maximum search depth reached
 }
 
 pub async fn eval_position_handler(
     State(state): State<ServerState>,
     Json(payload): Json<EvalRequest>
 ) -> impl IntoResponse {
     let current_board = match Board::from_str(&payload.current_fen) {
-        Ok(b) => b,
+        Ok(board) => board,
         Err(_) => {
             return (
                 StatusCode::BAD_REQUEST,
                 Json(BestMoveResponse {
-                    best_move: None,
+                    best_move: String::new(),
+                    line: vec![],
                     eval: 0,
                     nodes: 0,
                     time: 0,
@@ -50,10 +52,11 @@ pub async fn eval_position_handler(
         }
     };
 
+    // Reconstruct repetition history
     let mut history = RepetitionHistory::new();
     for fen in &payload.history {
-        if let Ok(board) = Board::from_str(fen) {
-            let hash = board.get_hash();
+        if let Ok(past_board) = Board::from_str(fen) {
+            let hash = past_board.get_hash();
             history.increment(hash);
         }
     }
@@ -69,18 +72,26 @@ pub async fn eval_position_handler(
         transposition_table,
     };
 
+    let start_time = Instant::now();
     let board = engine.current_board.clone();
-    let (best_move, nodes, time_taken_ms, eval, depth) = search(
+    let (line, nodes, _, eval, depth) = search(
         payload.time_left_ms,
         payload.time_limit_ms,
         &board,
         &mut engine
     );
+    let time_taken_ms = start_time.elapsed().as_millis();
+
+    let best_move_str = line.first().map_or(String::new(), |m| m.to_string());
 
     (
         StatusCode::OK,
         Json(BestMoveResponse {
-            best_move: best_move.map(|m| m.to_string()),
+            best_move: best_move_str,
+            line: line
+                .iter()
+                .map(|m| m.to_string())
+                .collect(),
             eval,
             nodes,
             time: time_taken_ms,

notebooks/benchmark.ipynb

@@ -1,24 +1,25 @@
-use axum::{ extract::State, http::StatusCode, response::IntoResponse, Json };
+use axum::{ extract::{ State, Json }, http::StatusCode, response::IntoResponse };
 use serde::{ Deserialize, Serialize };
-use std::{ time::Instant };
+use std::time::Instant;
 use crate::bot::{ algorithm::root::search, include::types::{ ServerState, Statistics } };
 
 #[derive(Debug, Deserialize)]
 pub struct BestMoveQuery {
-    game_id: String,
-    time_left_ms: u128,
-    time_limit_ms: Option<u128>,
-    update_state: Option<bool>,
+    pub game_id: String,
+    pub time_left_ms: u128,
+    pub time_limit_ms: Option<u128>,
+    pub update_state: Option<bool>,
 }
 
 #[derive(Debug, Serialize)]
 pub struct BestMoveResponse {
-    best_move: Option<String>,
-    eval: i32,
-    nodes: u64,
-    time: u128,
-    depth: u8,
-    new_position: String,
+    pub best_move: String,
+    pub line: Vec<String>, // Full principal variation
+    pub eval: i32,
+    pub nodes: u64,
+    pub time: u128,
+    pub depth: u8,
+    pub new_position: String,
 }
 
 pub async fn best_move_handler(
@@ -29,7 +30,8 @@ pub async fn best_move_handler(
         return (
             StatusCode::NOT_FOUND,
             Json(BestMoveResponse {
-                best_move: None,
+                best_move: String::new(),
+                line: vec![],
                 eval: 0,
                 nodes: 0,
                 time: 0,
@@ -42,27 +44,28 @@ pub async fn best_move_handler(
     let now = Instant::now();
     let board = engine.current_board.clone();
 
-    let (best_move, nodes, time, eval, depth) = search(
+    // search returns (Vec<ChessMove>, u64, u128, i32, u8)
+    let (line, nodes, _, eval, depth) = search(
         params.time_left_ms,
         params.time_limit_ms,
         &board,
         &mut engine
     );
-
     let time_taken_ms = now.elapsed().as_millis();
 
     let mut new_position = engine.current_board.to_string();
-    // Update engine state statistics if requested
+
+    let best_move_str = line.first().map_or(String::new(), |m| m.to_string());
+
     if params.update_state.unwrap_or(false) {
-        // Update cumulative statistics under a fixed key (e.g., 0)
         let key = engine.current_board.get_hash();
         engine.statistics.entry(key).or_insert(Statistics {
             nodes_explored: nodes,
-            time_taken_ms: time_taken_ms,
+            time_taken_ms,
         });
-        if let Some(best) = best_move {
-            // Update the current board with the selected move
-            let new_board = engine.current_board.make_move_new(best);
+
+        if let Some(first_move) = line.first() {
+            let new_board = engine.current_board.make_move_new(*first_move);
             engine.current_board = new_board;
             new_position = engine.current_board.to_string();
         }
@@ -71,10 +74,14 @@ pub async fn best_move_handler(
     (
         StatusCode::OK,
         Json(BestMoveResponse {
-            best_move: best_move.map(|m| m.to_string()),
+            best_move: best_move_str,
+            line: line
+                .iter()
+                .map(|m| m.to_string())
+                .collect(),
             eval,
             nodes,
-            time,
+            time: time_taken_ms,
             depth,
             new_position,
         }),