uci changes

Signed-off-by: Andreas Tsatsanis <[email protected]>

Author: andtsa

README.md

@@ -87,7 +87,7 @@ everything under [`./src/sandy/`](src/sandy/) is part of the frontend (almost)
 - [`./src/sandy/uci/search_controls.rs`](src/sandy/uci/search_controls.rs) does the same for search controls (eg `go depth 4`)
 
 ## Changelog
-- `v0.6.3` one more attempt at fixing 3fold repetition avoidance
+- `v0.6.3` quiescence search, breaking changes on `Opts`, one more attempt at fixing 3fold repetition avoidance
 - `v0.6.2` inline move ordering: switch from an allocated `Vec<ChessMove>` to an iterator that only generates moves as needed, performing all move ordering operations on the construction of the iterator.
 - `v0.6.1` variable search depth: when a node has <= 3 children, increase search depth by 1, just for this case. this massively helps lookahead in positions with a lot of checks 
 - lost versions: i did not actually keep a changelog until `v0.6.1`. i do not remember the details here

src/engine/evaluation/mod.rs

@@ -48,11 +48,12 @@ pub fn evaluate(pos: &Position, out_of_moves: bool) -> Value {
             optlog!(eval;debug;"eval stalemate");
             // in stalemate, give a negative score to the side that's winning to
             // encourage it to keep playing instead
-            value += material(&pos.chessboard, stm, (0.0, 0.0, 1.0));
-            value -= material(&pos.chessboard, stm.not(), (0.0, 0.0, 1.0));
-            value += piece_position_benefit_for_side(&pos.chessboard, stm, (0.0, 0.0, 1.0));
-            value -= piece_position_benefit_for_side(&pos.chessboard, stm.not(), (0.0, 0.0, 1.0));
-            -2 * value
+            let interp = interpolate(&pos.chessboard);
+            value += material(&pos.chessboard, stm, interp);
+            value -= material(&pos.chessboard, stm.not(), interp);
+            value += piece_position_benefit_for_side(&pos.chessboard, stm, interp);
+            value -= piece_position_benefit_for_side(&pos.chessboard, stm.not(), interp);
+            -2 * (value + TEMPO + TEMPO)
         } else {
             // Side to move is checkmated
             optlog!(eval;trace;"eval checkmate");

src/engine/opts.rs

@@ -12,6 +12,11 @@ use crate::optlog;
 use crate::search::SEARCH_THREADS;
 use crate::transposition_table::DEFAULT_TABLE_SIZE;
 
+/// limit transposition table size to 64gb.
+/// this limit depends on the currenly used implementation for the hash table,
+/// as unfortunately bigger isn't always better.
+const MAX_HASH_SIZE: i64 = 65536;
+
 /// Read the global options for the engine, attempting to go through the
 /// [`RwLock`] of [`OPTS`] to do so
 #[inline(always)]
@@ -217,7 +222,7 @@ impl Opts {
                 name: "hash".to_string(),
                 default: Some((DEFAULT_TABLE_SIZE / (1024 * 1024)).max(1) as i64),
                 min: Some(0),
-                max: Some(4096),
+                max: Some(MAX_HASH_SIZE),
             },
             UciOptionConfig::Spin {
                 name: "threads".to_string(),
@@ -270,7 +275,7 @@ impl Opts {
             // hash input is in megabytes, according to UCI specification
             "hash" => {
                 self.engine_opts.hash_size =
-                    1024 * 1024 * parse_spin("hash", 0, 1024, value)? as usize
+                    1024 * 1024 * parse_spin("hash", 0, MAX_HASH_SIZE, value)? as usize
             }
             "threads" => self.engine_opts.threads = parse_spin("threads", 0, 1024, value)? as usize,
             unknown => bail!("unknown option: {:?}", unknown),

src/engine/search/negamax.rs

@@ -123,27 +123,27 @@ pub fn negamax(
 
     /* source: https://en.wikipedia.org/wiki/Negamax */
     let alpha_orig = alpha;
-    if opts.use_tt {
-        if let Ok(Some(tt_entry)) = table.read().map(|l| l.get(current_hash)) {
-            if tt_entry.is_valid() {
-                if tt_entry.depth() >= to_depth {
-                    match tt_entry.bound() {
-                        EvalBound::Exact => return tt_entry.search_result(),
-                        EvalBound::LowerBound => {
-                            alpha = alpha.max(tt_entry.search_result().next_position_value)
-                        }
-                        EvalBound::UpperBound => {
-                            beta = beta.min(tt_entry.search_result().next_position_value)
-                        }
+    if opts.use_tt
+        && let Ok(Some(tt_entry)) = table.read().map(|l| l.get(current_hash))
+    {
+        if tt_entry.is_valid() {
+            if tt_entry.depth() >= to_depth {
+                match tt_entry.bound() {
+                    EvalBound::Exact => return tt_entry.search_result(),
+                    EvalBound::LowerBound => {
+                        alpha = alpha.max(tt_entry.search_result().next_position_value)
+                    }
+                    EvalBound::UpperBound => {
+                        beta = beta.min(tt_entry.search_result().next_position_value)
                     }
                 }
-                if alpha >= beta {
-                    return tt_entry.search_result();
-                }
             }
-            pre_generated[0] = Some(tt_entry.mv());
-            base_gen.remove_move(tt_entry.mv());
+            if alpha >= beta {
+                return tt_entry.search_result();
+            }
         }
+        pre_generated[0] = Some(tt_entry.mv());
+        base_gen.remove_move(tt_entry.mv());
     }
 
     if to_depth == Depth::ZERO {

src/sandy/uci/mod.rs

@@ -72,8 +72,15 @@ pub fn uci_loop(mut engine: Engine) -> Result<()> {
                     Ok(opt) => {
                         setopts(opt)?;
                         engine.eng_opts = opt.engine_opts;
-                        let entry_count = engine.resize_table(engine.eng_opts.hash_size)?;
-                        println!("info string table resized to {entry_count} entries.");
+                        if name == "hash" {
+                            println!("info string resizing table...");
+                            let start_alloc_time = Instant::now();
+                            let entry_count = engine.resize_table(engine.eng_opts.hash_size)?;
+                            println!(
+                                "info string table resized to {entry_count} entries in {}s",
+                                start_alloc_time.elapsed().as_secs_f32()
+                            );
+                        }
 
                         optlog!(uci;info;
                              "option {name} set to {}.",