Skip to content
New issue

Have a question about this project? Sign up for a free GitHub account to open an issue and contact its maintainers and the community.

Sign up for GitHub

By clicking “Sign up for GitHub”, you agree to our terms of service and privacy statement. We’ll occasionally send you account related emails.

Already on GitHub? Sign in to your account

Jump to bottom

TT: Aging and smaller entries #19

Merged
merged 6 commits into from
Mar 1, 2023
Merged

TT: Aging and smaller entries #19

Show file tree
Hide file tree
Changes from all commits
Commits
Show all changes
6 commits
Select commit Hold shift + click to select a range
e368f46
aging and smaller entries
crippa1337 Feb 28, 2023
6a8e852
fix assertion error
crippa1337 Feb 28, 2023
eee81b1
Non-bugged pv table, const generics
crippa1337 Mar 1, 2023
be3086f
Change PVS PV call
crippa1337 Mar 1, 2023
b154863
Refactor quality function
crippa1337 Mar 1, 2023
fde2740
New aging formula
crippa1337 Mar 1, 2023
File filter

Filter by extension

Filter by extension
Conversations
Failed to load comments.
Loading
Jump to
Jump to file
Failed to load files.
Loading
Diff view
Diff view
36 changes: 14 additions & 22 deletions src/engine/pv_table.rs
View file
Open in desktop
Original file line number Diff line number Diff line change
Expand Up @@ -3,42 +3,34 @@ use crate::uci::reverse_castling_move;
use cozy_chess::{Board, Move};

pub struct PVTable {
pub length: [u8; MAX_PLY as usize],
pub table: [[Option<Move>; MAX_PLY as usize]; MAX_PLY as usize],
pub length: usize,
pub table: [Option<Move>; MAX_PLY as usize],
}

impl PVTable {
pub fn new() -> Self {
PVTable {
length: [0; MAX_PLY as usize],
table: [[None; MAX_PLY as usize]; MAX_PLY as usize],
length: 0,
table: [None; MAX_PLY as usize],
}
}

pub fn store(&mut self, board: &Board, ply: u8, mut mv: Move) {
// Write to PV table
let uply = ply as usize;
mv = reverse_castling_move(board, mv);
self.table[uply][uply] = Some(mv);

// Loop over the next ply
for i in (uply + 1)..self.length[uply + 1] as usize {
// Copy move from deeper ply into current line
self.table[uply][i] = self.table[uply + 1][i];
}
pub fn store(&mut self, board: &Board, mv: Move, old: &Self) {
let mv = reverse_castling_move(board, mv);
self.table[0] = Some(mv);
self.table[1..=old.length].copy_from_slice(&old.table[..old.length]);
self.length = old.length + 1;
}

// Update PV length
self.length[uply] = self.length[uply + 1];
pub fn moves(&self) -> &[Option<Move>] {
&self.table[..self.length]
}

pub fn pv_string(&self) -> String {
let mut pv = String::new();
for i in 0..self.length[0] {
if self.table[0][i as usize].is_none() {
break;
}
for &mv in self.moves() {
pv.push(' ');
pv.push_str(&self.table[0][i as usize].unwrap().to_string());
pv.push_str(mv.unwrap().to_string().as_str());
}

pv
Expand Down
107 changes: 74 additions & 33 deletions src/engine/search.rs
View file
Open in desktop
Original file line number Diff line number Diff line change
Expand Up @@ -22,7 +22,6 @@ pub struct Search {
pub search_type: SearchType,
pub timer: Option<Instant>,
pub goal_time: Option<u64>,
pub pv_table: PVTable,
pub nodes: u32,
pub seldepth: u8,
pub tt: TT,
Expand All @@ -38,7 +37,6 @@ impl Search {
search_type: SearchType::Depth(0),
timer: None,
goal_time: None,
pv_table: PVTable::new(),
nodes: 0,
seldepth: 0,
tt,
Expand All @@ -48,14 +46,29 @@ impl Search {
}
}

pub fn pvsearch(
// Zero Window Search - A way to reduce the search space in alpha-beta like search algorithms,
// to perform a boolean test, whether a move produces a worse or better score than a passed value.
// (https://www.chessprogramming.org/Null_Window)
fn zw_search(
&mut self,
board: &Board,
pv: &mut PVTable,
alpha: i16,
beta: i16,
depth: u8,
ply: u8,
) -> i16 {
self.pvsearch::<false>(board, pv, alpha, beta, depth, ply)
}

pub fn pvsearch<const PV: bool>(
&mut self,
board: &Board,
pv: &mut PVTable,
mut alpha: i16,
beta: i16,
depth: u8,
ply: u8,
is_pv: bool,
) -> i16 {
// Every 1024 nodes, check if it's time to stop
if let (Some(timer), Some(goal)) = (self.timer, self.goal_time) {
Expand All @@ -74,7 +87,8 @@ impl Search {
}

self.seldepth = max(self.seldepth, ply);
self.pv_table.length[ply as usize] = ply;
pv.length = 0;
let mut old_pv = PVTable::new();

match board.status() {
GameStatus::Won => return ply as i16 - MATE,
Expand Down Expand Up @@ -110,20 +124,20 @@ impl Search {
/////////////////////////////////

let tt_entry = self.tt.probe(hash_key);
let tt_hit = tt_entry.key == hash_key;
let tt_hit = tt_entry.key == hash_key as u16;
let mut tt_move: Option<Move> = None;
if tt_hit {
let tt_score = self.tt.score_from_tt(tt_entry.score, ply);
tt_move = tt_entry.mv;
// Use the TT score if available since eval is expensive
eval = tt_score;

if !is_pv && tt_entry.depth >= depth {
assert!(tt_score != NONE && tt_entry.flags != TTFlag::None);
if !PV && tt_entry.depth >= depth {
assert!(tt_score != NONE && tt_entry.flag != TTFlag::None);

if (tt_entry.flags == TTFlag::Exact)
|| (tt_entry.flags == TTFlag::LowerBound && tt_score >= beta)
|| (tt_entry.flags == TTFlag::UpperBound && tt_score <= alpha)
if (tt_entry.flag == TTFlag::Exact)
|| (tt_entry.flag == TTFlag::LowerBound && tt_score >= beta)
|| (tt_entry.flag == TTFlag::UpperBound && tt_score <= alpha)
{
return tt_score;
}
Expand All @@ -138,7 +152,7 @@ impl Search {
// Pre-search pruning techniques //
///////////////////////////////////

if !is_pv {
if !PV {
// Null Move Pruning (NMP)
// If we can give the opponent a free move and still cause a beta cutoff,
// we can safely prune this node. This does not work in zugzwang positions
Expand All @@ -154,7 +168,7 @@ impl Search {
let d = depth.saturating_sub(r);
let new_board = board.null_move().unwrap();

let score = -self.pvsearch(&new_board, -beta, -beta + 1, d, ply + 1, false);
let score = -self.zw_search(&new_board, &mut old_pv, -beta, -beta + 1, d, ply + 1);

if score >= beta {
if score >= TB_WIN_IN_PLY {
Expand Down Expand Up @@ -184,7 +198,7 @@ impl Search {
let mut best_move: Option<Move> = None;
let mut move_list = movegen::all_moves(self, board, tt_move, ply);
let mut quiet_moves = StaticVec::<Option<Move>, MAX_MOVES_POSITION>::new(None);
let lmr_depth = if is_pv { 4 } else { 2 };
let lmr_depth = if PV { 4 } else { 2 };

for i in 0..move_list.len() {
let mv = movegen::pick_move(&mut move_list, i);
Expand All @@ -194,7 +208,7 @@ impl Search {
}

let mut new_board = board.clone();
new_board.play(mv);
new_board.play_unchecked(mv);

self.game_history.push(new_board.hash()); // Repetition detection
self.nodes += 1;
Expand All @@ -203,7 +217,14 @@ impl Search {
// Principal Variation Search
let mut score: i16;
if i == 0 {
score = -self.pvsearch(&new_board, -beta, -alpha, depth - 1, ply + 1, is_pv);
score = -self.pvsearch::<PV>(
&new_board,
&mut old_pv,
-beta,
-alpha,
depth - 1,
ply + 1,
);
} else {
// Late Move Reduction (LMR)
// Assuming our move ordering is good, later moves will be worse
Expand All @@ -214,7 +235,7 @@ impl Search {
let mut r = LMR.reduction(depth, i) as u8;

// Bonus for non PV nodes
r += u8::from(!is_pv);
r += u8::from(!PV);

// Malus for capture moves and checks
r -= u8::from(capture_move(board, mv));
Expand All @@ -227,10 +248,23 @@ impl Search {
1
};

// Zero window search
score = -self.pvsearch(&new_board, -alpha - 1, -alpha, depth - r, ply + 1, false);
score = -self.zw_search(
&new_board,
&mut old_pv,
-alpha - 1,
-alpha,
depth - r,
ply + 1,
);
if alpha < score && score < beta {
score = -self.pvsearch(&new_board, -beta, -alpha, depth - 1, ply + 1, true);
score = -self.pvsearch::<PV>(
&new_board,
&mut old_pv,
-beta,
-alpha,
depth - 1,
ply + 1,
);
}
}

Expand All @@ -242,7 +276,7 @@ impl Search {
if score > alpha {
alpha = score;
best_move = Some(mv);
self.pv_table.store(board, ply, mv);
pv.store(board, mv, &old_pv);

if score >= beta {
if quiet_move(board, mv) {
Expand Down Expand Up @@ -309,17 +343,17 @@ impl Search {

let hash_key = board.hash();
let tt_entry = self.tt.probe(hash_key);
let tt_hit = tt_entry.key == hash_key;
let tt_hit = tt_entry.key == hash_key as u16;
let mut tt_move: Option<Move> = None;
if tt_hit && !is_pv {
if tt_hit && !is_pv && tt_entry.flag != TTFlag::None {
let tt_score = self.tt.score_from_tt(tt_entry.score, ply);
tt_move = tt_entry.mv;

assert!(tt_score != NONE && tt_entry.flags != TTFlag::None);
assert!(tt_score != NONE);

if (tt_entry.flags == TTFlag::Exact)
|| (tt_entry.flags == TTFlag::LowerBound && tt_score >= beta)
|| (tt_entry.flags == TTFlag::UpperBound && tt_score <= alpha)
if (tt_entry.flag == TTFlag::Exact)
|| (tt_entry.flag == TTFlag::LowerBound && tt_score >= beta)
|| (tt_entry.flag == TTFlag::UpperBound && tt_score <= alpha)
{
return tt_score;
}
Expand All @@ -332,7 +366,7 @@ impl Search {
for i in 0..captures.len() {
let mv = movegen::pick_move(&mut captures, i);
let mut new_board = board.clone();
new_board.play(mv);
new_board.play_unchecked(mv);

self.nodes += 1;

Expand Down Expand Up @@ -383,17 +417,18 @@ impl Search {
let mut best_move: Option<Move> = None;

let mut score: i16 = 0;
let mut pv = PVTable::new();

for d in 1..depth + 1 {
self.seldepth = 0;
score = self.aspiration_window(board, score, d);
score = self.aspiration_window(board, &mut pv, score, d);

// Search wasn't complete, do not update best move with garbage
if self.stop && d > 1 {
break;
}

best_move = self.pv_table.table[0][0];
best_move = pv.table[0];

println!(
"info depth {} seldepth {} score {} nodes {} time {} pv{}",
Expand All @@ -402,14 +437,20 @@ impl Search {
self.format_score(score),
self.nodes,
info_timer.elapsed().as_millis(),
self.pv_table.pv_string()
pv.pv_string()
);
}

println!("bestmove {}", best_move.unwrap());
}

fn aspiration_window(&mut self, board: &Board, prev_eval: i16, depth: u8) -> i16 {
fn aspiration_window(
&mut self,
board: &Board,
pv: &mut PVTable,
prev_eval: i16,
depth: u8,
) -> i16 {
let mut score: i16;

// Window size
Expand All @@ -425,7 +466,7 @@ impl Search {
}

loop {
score = self.pvsearch(board, alpha, beta, depth, 0, true);
score = self.pvsearch::<true>(board, pv, alpha, beta, depth, 0);

// This result won't be used
if self.stop {
Expand Down
Loading