Upload folder using huggingface_hub

neural_engine/src/main.rs

@@ -1,7 +1,9 @@
 use std::collections::{HashMap, HashSet};
 use std::io::{self, BufRead};
 use std::sync::{Arc, Mutex};
-use std::sync::atomic::{AtomicBool, Ordering};
+use std::sync::atomic::{AtomicU64, AtomicBool, Ordering};
+
+static NODES_SEARCHED: AtomicU64 = AtomicU64::new(0);
 use dashmap::DashMap;
 use shakmaty::{Chess, Move, Position, Setup, CastlingMode};
 use shakmaty::zobrist::{Zobrist64, ZobristHash};
@@ -237,6 +239,7 @@ fn alpha_beta(
     stop_flag: &AtomicBool,
     is_null: bool,
 ) -> f32 {
+    NODES_SEARCHED.fetch_add(1, Ordering::Relaxed);
     if stop_flag.load(Ordering::Relaxed) { return 0.0; }
 
     if let Some(tb) = tablebases {
@@ -438,6 +441,8 @@ fn main() {
                 }
                 
                 tt.clear();
+                NODES_SEARCHED.store(0, Ordering::Relaxed);
+                let start_time = std::time::Instant::now();
                 let stop_flag = Arc::new(AtomicBool::new(false));
                 let mut handles = Vec::new();
                 
@@ -452,7 +457,7 @@ fn main() {
                     root_cache = Some(compute_root_kv_cache(&mut sess, &history_moves, &vocab));
                 }
 
-                for _thread_id in 0..num_threads {
+                for thread_id in 0..num_threads {
                     let t_board = board.clone();
                     let mut t_history = history_moves.clone();
                     let t_vocab = Arc::clone(&vocab);
@@ -518,6 +523,24 @@ fn main() {
                                 );
                             }
                             prev_score = score;
+                            
+                            let is_main_thread = thread_id == 0;
+                            if is_main_thread && !t_stop_flag.load(Ordering::Relaxed) {
+                                let elapsed = start_time.elapsed().as_secs_f64();
+                                let n = NODES_SEARCHED.load(Ordering::Relaxed);
+                                let nps = if elapsed > 0.0 { (n as f64 / elapsed) as u64 } else { 0 };
+                                let cp = (prev_score * 100.0) as i32;
+                                
+                                let mut pv = String::new();
+                                if let Some(entry) = t_tt.get(&global_root_hash) {
+                                    if let Some(m) = &entry.best_move {
+                                        pv = m.to_string();
+                                    }
+                                }
+                                
+                                println!("info depth {} score cp {} nodes {} nps {} time {} pv {}", 
+                                    depth, cp, n, nps, (elapsed * 1000.0) as u64, pv);
+                            }
                         }
                     });
                     handles.push(handle);