Merge pull request #166 from pleco-rs/fix-ci

chase-manning · web-flow · commit 4ba53e703ded · 2026-02-22T12:17:13.000Z
👷 Fix CI
diff --git a/TODO.md b/TODO.md
@@ -14,6 +14,7 @@ Raise PR for other protocols to use pleco again
 
 ## Development
 
+Fix CI
 Test engine in Arena: https://github.com/pleco-rs/Pleco/issues/132
 Port over Stockfish end of game table: https://github.com/pleco-rs/Pleco/issues/113
 Review unstable features and which ones we can add back: https://github.com/pleco-rs/Pleco/issues/77
diff --git a/pleco/src/board/mod.rs b/pleco/src/board/mod.rs
@@ -205,7 +205,7 @@ pub struct Board {
     half_moves: u16,                                  // Total moves played
     depth: u16,                                       // Current depth since last shallow_copy
     piece_counts: [[u8; PIECE_TYPE_CNT]; PLAYER_CNT], // Count of each Piece
-    piece_locations: PieceLocations,                  // Mapping Squares to Pieces and Plauers
+    piece_locations: PieceLocations,                  // Mapping Squares to Pieces and Players
     zobrist_history: Vec<u64>,                        // Historic Zobrist keys of the board
     threefold_repetition: bool,                       // Whether the board has been repeated 3 times
 
@@ -700,7 +700,7 @@ impl Board {
         let mut next_arc_state = UniqueArc::new(self.state.partial_clone());
 
         // Separate Block to allow dereferencing the BoardState
-        // As there is garunteed only one owner of the Arc, this is allowed
+        // As there is guaranteed only one owner of the Arc, this is allowed
         {
             let new_state: &mut BoardState = &mut next_arc_state;
 
@@ -1242,7 +1242,7 @@ impl Board {
     fn apply_castling(
         &mut self,
         player: Player,
-        k_src: SQ,          // from, king startng spot
+        k_src: SQ,          // from, king starting spot
         to_r_orig: &mut SQ, // originally
         r_src: &mut SQ,
         r_dst: &mut SQ,
diff --git a/pleco/src/board/movegen.rs b/pleco/src/board/movegen.rs
@@ -111,7 +111,7 @@ impl Legality for PseudoLegal {
     }
 }
 
-// Pieces to generate moves with inter-changably
+// Pieces to generate moves with interchangeably
 const STANDARD_PIECES: [PieceType; 4] = [PieceType::B, PieceType::N, PieceType::R, PieceType::Q];
 const DEFAULT_MOVES_LENGTH: usize = 32;
 
diff --git a/pleco/src/bots/mod.rs b/pleco/src/bots/mod.rs
@@ -120,7 +120,7 @@ pub fn eval_board(board: &Board) -> ScoringMove {
 mod tests {
     use super::*;
 
-    // We test these, as both algorithms should give the same result no matter if paralleized
+    // We test these, as both algorithms should give the same result no matter if parallelized
     // or not.
 
     #[test]
diff --git a/pleco/src/core/mod.rs b/pleco/src/core/mod.rs
@@ -522,7 +522,7 @@ impl Piece {
     ///
     /// The following code snippet will give undefined behavior:
     ///
-    /// ```
+    /// ```no_run
     /// use pleco::{Piece,PieceType,Player};
     ///
     /// let illegal_piece = Piece::make_lossy(Player::Black, PieceType::All);
diff --git a/pleco/src/helper/prelude.rs b/pleco/src/helper/prelude.rs
@@ -193,7 +193,7 @@ pub fn z_ep(sq: SQ) -> u64 {
     zobrist::z_ep(sq)
 }
 
-/// Returns the Zobrish hash for a castling right.
+/// Returns the Zobrist hash for a castling right.
 ///
 /// Undefined behavior will occur if the bits are greater than 15.
 #[inline(always)]
diff --git a/pleco/src/tools/tt.rs b/pleco/src/tools/tt.rs
@@ -43,7 +43,7 @@ use super::prefetch_write;
 use super::PreFetchable;
 use core::piece_move::BitMove;
 
-// TODO: investigate potention for SIMD in key lookup
+// TODO: investigate potential for SIMD in key lookup
 // Currently, there is now way to do this right now in rust without it being extensive.
 
 pub type Key = u64;
@@ -352,7 +352,7 @@ impl TranspositionTable {
     /// Returns the current number of cycles a TT has gone through. Cycles is simply the
     /// number of times refresh has been called.
     #[inline]
-    pub fn time_age_cylces(&self) -> u8 {
+    pub fn time_age_cycles(&self) -> u8 {
         unsafe { (*self.time_age.get()).wrapping_shr(2) }
     }
 
@@ -363,6 +363,7 @@ impl TranspositionTable {
     /// the current search, e.g. has the shallowest depth or was found in a previous search.
     ///
     /// If 'true' is returned, the Entry is guaranteed to have the correct time.
+    #[allow(clippy::mut_from_ref)]
     pub fn probe(&self, key: Key) -> (bool, &mut Entry) {
         let partial_key: u16 = (key).wrapping_shr(48) as u16;
 
diff --git a/pleco/tests/board_hash.rs b/pleco/tests/board_hash.rs
@@ -66,7 +66,7 @@ impl HashCorrect for PawnHashCorrect {
     }
 }
 
-// Testing that applying / undoing a move leads to the same zobriust hash
+// Testing that applying / undoing a move leads to the same zobrist hash
 #[test]
 fn zobrist_correctness() {
     for _x in 0..15 {
diff --git a/pleco_engine/src/consts.rs b/pleco_engine/src/consts.rs
@@ -1,5 +1,5 @@
 //! Constant values and static structures.
-use std::mem;
+use std::mem::MaybeUninit;
 use std::ptr;
 use std::sync::atomic::compiler_fence;
 use std::sync::atomic::AtomicBool;
@@ -22,22 +22,15 @@ pub const DEFAULT_TT_SIZE: usize = 256;
 pub const PAWN_TABLE_SIZE: usize = 16384;
 pub const MATERIAL_TABLE_SIZE: usize = 8192;
 
-const TT_ALLOC_SIZE: usize = mem::size_of::<TranspositionTable>();
-const TIMER_ALLOC_SIZE: usize = mem::size_of::<TimeManager>();
-
-// A object that is the same size as a transposition table
-type DummyTranspositionTable = [u8; TT_ALLOC_SIZE];
-type DummyTimeManager = [u8; TIMER_ALLOC_SIZE];
-
 pub static USE_STDOUT: AtomicBool = AtomicBool::new(true);
 
 static INITIALIZED: Once = Once::new();
 
 /// Global Transposition Table
-static mut TT_TABLE: DummyTranspositionTable = [0; TT_ALLOC_SIZE];
+static mut TT_TABLE: MaybeUninit<TranspositionTable> = MaybeUninit::uninit();
 
 // Global Timer
-static mut TIMER: DummyTimeManager = [0; TIMER_ALLOC_SIZE];
+static mut TIMER: MaybeUninit<TimeManager> = MaybeUninit::uninit();
 
 #[cold]
 pub fn init_globals() {
@@ -56,29 +49,30 @@ pub fn init_globals() {
 #[cold]
 fn init_tt() {
     unsafe {
-        let tt = &mut TT_TABLE as *mut DummyTranspositionTable as *mut TranspositionTable;
-        ptr::write(tt, TranspositionTable::new(DEFAULT_TT_SIZE));
+        ptr::write(
+            TT_TABLE.as_mut_ptr(),
+            TranspositionTable::new(DEFAULT_TT_SIZE),
+        );
     }
 }
 
 // Initializes the global Timer
 #[cold]
 fn init_timer() {
     unsafe {
-        let timer: *mut TimeManager = &mut TIMER as *mut DummyTimeManager as *mut TimeManager;
-        ptr::write(timer, TimeManager::uninitialized());
+        ptr::write(TIMER.as_mut_ptr(), TimeManager::uninitialized());
     }
 }
 
 // Returns access to the global timer
 pub fn timer() -> &'static TimeManager {
-    unsafe { &*(&TIMER as *const DummyTimeManager as *const TimeManager) }
+    unsafe { &*TIMER.as_ptr() }
 }
 
 /// Returns access to the global transposition table
 #[inline(always)]
 pub fn tt() -> &'static TranspositionTable {
-    unsafe { &*(&TT_TABLE as *const DummyTranspositionTable as *const TranspositionTable) }
+    unsafe { &*TT_TABLE.as_ptr() }
 }
 
 pub trait PVNode {
diff --git a/pleco_engine/src/search/eval.rs b/pleco_engine/src/search/eval.rs
@@ -266,7 +266,7 @@ const PAWNLESS_FLANK: Score = Score(20, 80);
 const THREAT_BY_SAFE_PAWN: Score = Score(192, 175);
 const THREAT_BY_RANK: Score = Score(16, 3);
 const HANGING: Score = Score(48, 27);
-const WEAK_UNOPOSSED_PAWN: Score = Score(5, 25);
+const WEAK_UNOPPOSED_PAWN: Score = Score(5, 25);
 const SLIDER_ON_QUEEN: Score = Score(42, 21);
 const THREAT_BY_PAWN_PUSH: Score = Score(38, 22);
 const THREAT_BY_ATTACK_ON_QUEEN: Score = Score(38, 22);
@@ -961,7 +961,7 @@ impl<'a, 'b, T: Tracing> EvaluationInner<'a, 'b, T> {
             .piece_two_bb(PieceType::R, PieceType::Q, us)
             .is_not_empty()
         {
-            score += WEAK_UNOPOSSED_PAWN * self.pawn_entry.weak_unopposed(them);
+            score += WEAK_UNOPPOSED_PAWN * self.pawn_entry.weak_unopposed(them);
         }
 
         // Find squares where our pawns can push on the next move
diff --git a/pleco_engine/src/search/mod.rs b/pleco_engine/src/search/mod.rs
@@ -293,7 +293,7 @@ impl Searcher {
 
     // The per thread searching function
     fn search_root(&mut self) {
-        // Early return. This shouldn't notmally happen.
+        // Early return. This shouldn't normally happen.
         if self.stop() {
             return;
         }
@@ -790,8 +790,8 @@ impl Searcher {
                     // Countermoves based pruning
                     unsafe {
                         if lmr_depth < 3
-                            && (*cont_hists[0])[(moved_piece, mov.get_dest())] < 0
-                            && (*cont_hists[1])[(moved_piece, mov.get_dest())] < 0
+                            && (&(*cont_hists[0]))[(moved_piece, mov.get_dest())] < 0
+                            && (&(*cont_hists[1]))[(moved_piece, mov.get_dest())] < 0
                         {
                             continue;
                         }
@@ -881,9 +881,9 @@ impl Searcher {
 
                     ss.stat_score = unsafe {
                         self.main_history[(!self.board.turn(), mov)] as i32
-                            + (*cont_hists[0])[(moved_piece, mov.get_dest())] as i32
-                            + (*cont_hists[1])[(moved_piece, mov.get_dest())] as i32
-                            + (*cont_hists[3])[(moved_piece, mov.get_dest())] as i32
+                            + (&(*cont_hists[0]))[(moved_piece, mov.get_dest())] as i32
+                            + (&(*cont_hists[1]))[(moved_piece, mov.get_dest())] as i32
+                            + (&(*cont_hists[3]))[(moved_piece, mov.get_dest())] as i32
                             - 4000
                     };
 
@@ -948,7 +948,7 @@ impl Searcher {
                         rm.score = NEG_INFINITE;
                     }
                 }
-                // If we have a new best move at root, update the nmber of best_move changes.
+                // If we have a new best move at root, update the number of best_move changes.
                 if incr_bmc {
                     self.best_move_changes += 1.0;
                 }
diff --git a/pleco_engine/src/tables/pawn_table.rs b/pleco_engine/src/tables/pawn_table.rs
@@ -377,7 +377,7 @@ impl PawnEntry {
             {
                 0 // Blocked By King
             } else if rk_us == Rank::R1 {
-                1 // Unopossed
+                1 // Unopposed
             } else if rk_them as u8 == rk_us as u8 + 1 {
                 2 // Blocked by Pawn
             } else {
diff --git a/pleco_engine/src/threadpool/mod.rs b/pleco_engine/src/threadpool/mod.rs
@@ -2,6 +2,7 @@
 
 use std::alloc::{alloc_zeroed, dealloc, Layout};
 use std::cell::UnsafeCell;
+use std::mem::MaybeUninit;
 use std::ptr::NonNull;
 use std::sync::atomic::{AtomicBool, Ordering};
 use std::sync::Once;
@@ -21,43 +22,31 @@ use consts::*;
 
 const KILOBYTE: usize = 1000;
 const THREAD_STACK_SIZE: usize = 18000 * KILOBYTE;
-const POOL_SIZE: usize = mem::size_of::<ThreadPool>();
 
-// An object that is the same size as a thread pool.
-type DummyThreadPool = [u8; POOL_SIZE];
-
-// The Global threadpool! Yes, this is *technically* an array the same
-// size as a ThreadPool object. This is a cheap hack to get a global value, as
-// Rust isn't particularly fond of mutable global statics.
-pub static mut THREADPOOL: DummyThreadPool = [0; POOL_SIZE];
+pub static mut THREADPOOL: MaybeUninit<ThreadPool> = MaybeUninit::uninit();
 
 // ONCE for the Threadpool
 static THREADPOOL_INIT: Once = Once::new();
 
 // Initializes the threadpool, called once on startup.
 #[cold]
 pub fn init_threadpool() {
-    THREADPOOL_INIT.call_once(|| {
-        unsafe {
-            // We have a spawned thread create all structures, as a stack overflow can
-            // occur otherwise
-            let builder = thread::Builder::new()
-                .name("Starter".to_string())
-                .stack_size(THREAD_STACK_SIZE);
-
-            let handle = builder.spawn(|| {
-                let pool: *mut ThreadPool = mem::transmute(&mut THREADPOOL);
-                ptr::write(pool, ThreadPool::new());
-            });
-            handle.unwrap().join().unwrap();
-        }
+    THREADPOOL_INIT.call_once(|| unsafe {
+        let builder = thread::Builder::new()
+            .name("Starter".to_string())
+            .stack_size(THREAD_STACK_SIZE);
+
+        let handle = builder.spawn(|| {
+            ptr::write(THREADPOOL.as_mut_ptr(), ThreadPool::new());
+        });
+        handle.unwrap().join().unwrap();
     });
 }
 
 /// Returns access to the global thread pool.
 #[inline(always)]
 pub fn threadpool() -> &'static mut ThreadPool {
-    unsafe { mem::transmute::<&mut DummyThreadPool, &'static mut ThreadPool>(&mut THREADPOOL) }
+    unsafe { &mut *THREADPOOL.as_mut_ptr() }
 }
 
 #[derive(Copy, Clone)]
diff --git a/pleco_engine/src/time/uci_timer.rs b/pleco_engine/src/time/uci_timer.rs
@@ -25,7 +25,7 @@ impl LimitsType {
 #[derive(Clone)]
 pub struct UCITimer {
     pub time_msec: [i64; PLAYER_CNT], // time each player has remaining
-    pub inc_msec: [i64; PLAYER_CNT],  // increments for each palyer after each turn
+    pub inc_msec: [i64; PLAYER_CNT],  // increments for each player after each turn
     pub moves_to_go: u32,             // Moves to go until next time control sent
 }
 

Original file line number	Diff line number	Diff line change
`@@ -111,7 +111,7 @@ impl Legality for PseudoLegal {`
`111`	`111`	`}`
`112`	`112`	`}`
`113`	`113`
`114`		`-// Pieces to generate moves with inter-changably`
	`114`	`+// Pieces to generate moves with interchangeably`
`115`	`115`	`const STANDARD_PIECES: [PieceType; 4] = [PieceType::B, PieceType::N, PieceType::R, PieceType::Q];`
`116`	`116`	`const DEFAULT_MOVES_LENGTH: usize = 32;`
`117`	`117`
Original file line number	Diff line number	Diff line change
`@@ -193,7 +193,7 @@ pub fn z_ep(sq: SQ) -> u64 {`
`193`	`193`	`zobrist::z_ep(sq)`
`194`	`194`	`}`
`195`	`195`
`196`		`-/// Returns the Zobrish hash for a castling right.`
	`196`	`+/// Returns the Zobrist hash for a castling right.`
`197`	`197`	`///`
`198`	`198`	`/// Undefined behavior will occur if the bits are greater than 15.`
`199`	`199`	`#[inline(always)]`
Original file line number	Diff line number	Diff line change
`@@ -66,7 +66,7 @@ impl HashCorrect for PawnHashCorrect {`
`66`	`66`	`}`
`67`	`67`	`}`
`68`	`68`
`69`		`-// Testing that applying / undoing a move leads to the same zobriust hash`
	`69`	`+// Testing that applying / undoing a move leads to the same zobrist hash`
`70`	`70`	`#[test]`
`71`	`71`	`fn zobrist_correctness() {`
`72`	`72`	`for _x in 0..15 {`